diff --git a/API.md b/API.md
index 09c01a957..344410e39 100644
--- a/API.md
+++ b/API.md
@@ -110,7 +110,7 @@ A **line** is a way that is not an area. Elements representing lines have a `.li
 class. Since a line is also a way, they also have a `.way` class.
 
 An **area** is a way that is circular, has certain tags, or lacks certain other
-tags (see `iD.Way#isArea` for the exact definition). Elements representing areas
+tags (see `iD.osmWay#isArea` for the exact definition). Elements representing areas
 have `.area` and `.way` classes.
 
 
@@ -302,7 +302,7 @@ The minimum zoom at which iD enters the edit mode is configured using the `conte
 
 ```js
 
-var id = iD.Context()
+var id = iD.coreContext()
   .minEditableZoom(zoom_level)
 
 ```
diff --git a/data/presets/README.md b/data/presets/README.md
index 0a07f602f..e484a9478 100644
--- a/data/presets/README.md
+++ b/data/presets/README.md
@@ -89,7 +89,7 @@ preset are used. For example, `shop/convenience` automatically uses the same
 fields as `shop`.
 
 In both explicit and implicit inheritance, fields for keys that define the
-preset are not inherited. E.g. the `shop` field is not inherited by `shop/…` presets.  
+preset are not inherited. E.g. the `shop` field is not inherited by `shop/…` presets.
 
 ##### `searchable`
 
@@ -320,7 +320,7 @@ iD supports deployments which use a custom set of presets. You can supply preset
 the `presets` accessor:
 
 ```js
-var id = iD.Context().presets({
+var id = iD.coreContext().presets({
     presets: { ... },
     fields: { ... },
     defaults: { ... },
diff --git a/index.html b/index.html
index 7d228f1db..20674de66 100644
--- a/index.html
+++ b/index.html
@@ -13,7 +13,7 @@
         <div id='id-container'></div>
         <script>
 
-        id = iD.Context()
+        id = iD.coreContext()
             .assetPath('dist/');
 
         // disable boundaries (unless we have an explicit disable_features list)
diff --git a/test/spec/actions/add_entity.js b/test/spec/actions/add_entity.js
index f5351abe3..8c86981f5 100644
--- a/test/spec/actions/add_entity.js
+++ b/test/spec/actions/add_entity.js
@@ -1,7 +1,7 @@
 describe('iD.actionAddEntity', function () {
     it('adds an entity to the graph', function () {
         var entity = iD.Entity(),
-            graph = iD.actionAddEntity(entity)(iD.Graph());
+            graph = iD.actionAddEntity(entity)(iD.coreGraph());
         expect(graph.entity(entity.id)).to.equal(entity);
     });
 });
diff --git a/test/spec/actions/add_midpoint.js b/test/spec/actions/add_midpoint.js
index ba31d37e6..c983ac2f2 100644
--- a/test/spec/actions/add_midpoint.js
+++ b/test/spec/actions/add_midpoint.js
@@ -1,35 +1,35 @@
 describe('iD.actionAddMidpoint', function () {
     it('adds the node at the midpoint location', function () {
-        var node = iD.Node(),
-            a = iD.Node(),
-            b = iD.Node(),
+        var node = iD.osmNode(),
+            a = iD.osmNode(),
+            b = iD.osmNode(),
             midpoint = {loc: [1, 2], edge: [a.id, b.id]},
-            graph = iD.actionAddMidpoint(midpoint, node)(iD.Graph([a, b]));
+            graph = iD.actionAddMidpoint(midpoint, node)(iD.coreGraph([a, b]));
 
         expect(graph.entity(node.id).loc).to.eql([1, 2]);
     });
 
     it('adds the node to a way that contains the given edge in forward order', function () {
-        var node = iD.Node(),
-            a = iD.Node(),
-            b = iD.Node(),
-            w1 = iD.Way(),
-            w2 = iD.Way({nodes: [a.id, b.id]}),
+        var node = iD.osmNode(),
+            a = iD.osmNode(),
+            b = iD.osmNode(),
+            w1 = iD.osmWay(),
+            w2 = iD.osmWay({nodes: [a.id, b.id]}),
             midpoint = {loc: [1, 2], edge: [a.id, b.id]},
-            graph = iD.actionAddMidpoint(midpoint, node)(iD.Graph([a, b, w1, w2]));
+            graph = iD.actionAddMidpoint(midpoint, node)(iD.coreGraph([a, b, w1, w2]));
 
         expect(graph.entity(w1.id).nodes).to.eql([]);
         expect(graph.entity(w2.id).nodes).to.eql([a.id, node.id, b.id]);
     });
 
     it('adds the node to a way that contains the given edge in reverse order', function () {
-        var node = iD.Node(),
-            a = iD.Node(),
-            b = iD.Node(),
-            w1 = iD.Way(),
-            w2 = iD.Way({nodes: [b.id, a.id]}),
+        var node = iD.osmNode(),
+            a = iD.osmNode(),
+            b = iD.osmNode(),
+            w1 = iD.osmWay(),
+            w2 = iD.osmWay({nodes: [b.id, a.id]}),
             midpoint = {loc: [1, 2], edge: [a.id, b.id]},
-            graph = iD.actionAddMidpoint(midpoint, node)(iD.Graph([a, b, w1, w2]));
+            graph = iD.actionAddMidpoint(midpoint, node)(iD.coreGraph([a, b, w1, w2]));
 
         expect(graph.entity(w1.id).nodes).to.eql([]);
         expect(graph.entity(w2.id).nodes).to.eql([b.id, node.id, a.id]);
@@ -42,12 +42,12 @@ describe('iD.actionAddMidpoint', function () {
         //  \ /
         //   c
 
-        var a = iD.Node(),
-            b = iD.Node(),
-            c = iD.Node(),
-            w = iD.Way({nodes: [a.id, b.id, a.id]}),
+        var a = iD.osmNode(),
+            b = iD.osmNode(),
+            c = iD.osmNode(),
+            w = iD.osmWay({nodes: [a.id, b.id, a.id]}),
             midpoint = {loc: [1, 2], edge: [a.id, b.id]},
-            graph = iD.actionAddMidpoint(midpoint, c)(iD.Graph([a, b, w]));
+            graph = iD.actionAddMidpoint(midpoint, c)(iD.coreGraph([a, b, w]));
 
         expect(graph.entity(w.id).nodes).to.eql([a.id, c.id, b.id, a.id]);
     });
diff --git a/test/spec/actions/change_member.js b/test/spec/actions/change_member.js
index 90a41996a..4667283e4 100644
--- a/test/spec/actions/change_member.js
+++ b/test/spec/actions/change_member.js
@@ -1,9 +1,9 @@
 describe('iD.actionChangeMember', function () {
     it('updates the member at the specified index', function () {
-        var node     = iD.Node(),
-            relation = iD.Relation({members: [{id: node.id}]}),
+        var node     = iD.osmNode(),
+            relation = iD.osmRelation({members: [{id: node.id}]}),
             action   = iD.actionChangeMember(relation.id, {id: node.id, role: 'node'}, 0),
-            graph    = action(iD.Graph([node, relation]));
+            graph    = action(iD.coreGraph([node, relation]));
         expect(graph.entity(relation.id).members).to.eql([{id: node.id, role: 'node'}]);
     });
 });
diff --git a/test/spec/actions/change_preset.js b/test/spec/actions/change_preset.js
index 0a2e61bea..a80623849 100644
--- a/test/spec/actions/change_preset.js
+++ b/test/spec/actions/change_preset.js
@@ -3,22 +3,22 @@ describe('iD.actionChangePreset', function() {
         newPreset = iD.presetPreset('new', {tags: {new: 'true'}});
 
     it('changes from one preset\'s tags to another\'s', function() {
-        var entity = iD.Node({tags: {old: 'true'}}),
-            graph = iD.Graph([entity]),
+        var entity = iD.osmNode({tags: {old: 'true'}}),
+            graph = iD.coreGraph([entity]),
             action = iD.actionChangePreset(entity.id, oldPreset, newPreset);
         expect(action(graph).entity(entity.id).tags).to.eql({new: 'true'});
     });
 
     it('adds the tags of a new preset to an entity without an old preset', function() {
-        var entity = iD.Node(),
-            graph = iD.Graph([entity]),
+        var entity = iD.osmNode(),
+            graph = iD.coreGraph([entity]),
             action = iD.actionChangePreset(entity.id, null, newPreset);
         expect(action(graph).entity(entity.id).tags).to.eql({new: 'true'});
     });
 
     it('removes the tags of an old preset from an entity without a new preset', function() {
-        var entity = iD.Node({tags: {old: 'true'}}),
-            graph = iD.Graph([entity]),
+        var entity = iD.osmNode({tags: {old: 'true'}}),
+            graph = iD.coreGraph([entity]),
             action = iD.actionChangePreset(entity.id, oldPreset, null);
         expect(action(graph).entity(entity.id).tags).to.eql({});
     });
diff --git a/test/spec/actions/change_tags.js b/test/spec/actions/change_tags.js
index 1c3d83ef0..17e544f7d 100644
--- a/test/spec/actions/change_tags.js
+++ b/test/spec/actions/change_tags.js
@@ -2,7 +2,7 @@ describe('iD.actionChangeTags', function () {
     it('changes an entity\'s tags', function () {
         var entity = iD.Entity(),
             tags   = {foo: 'bar'},
-            graph  = iD.actionChangeTags(entity.id, tags)(iD.Graph([entity]));
+            graph  = iD.actionChangeTags(entity.id, tags)(iD.coreGraph([entity]));
         expect(graph.entity(entity.id).tags).to.eql(tags);
     });
 });
diff --git a/test/spec/actions/circularize.js b/test/spec/actions/circularize.js
index 5d7e4c73c..e20b268fe 100644
--- a/test/spec/actions/circularize.js
+++ b/test/spec/actions/circularize.js
@@ -50,12 +50,12 @@ describe('iD.actionCircularize', function () {
         //    d ---- c
         //    |      |
         //    a ---- b
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [2, 0]}),
-                iD.Node({id: 'c', loc: [2, 2]}),
-                iD.Node({id: 'd', loc: [0, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [2, 0]}),
+                iD.osmNode({id: 'c', loc: [2, 2]}),
+                iD.osmNode({id: 'd', loc: [0, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
             ]);
 
         graph = iD.actionCircularize('-', projection)(graph);
@@ -68,13 +68,13 @@ describe('iD.actionCircularize', function () {
         //    d,e -- c
         //    |      |
         //    a ---- b
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [2, 0]}),
-                iD.Node({id: 'c', loc: [2, 2]}),
-                iD.Node({id: 'd', loc: [0, 2]}),
-                iD.Node({id: 'e', loc: [0, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [2, 0]}),
+                iD.osmNode({id: 'c', loc: [2, 2]}),
+                iD.osmNode({id: 'd', loc: [0, 2]}),
+                iD.osmNode({id: 'e', loc: [0, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']})
             ]),
             nodes;
 
@@ -94,13 +94,13 @@ describe('iD.actionCircularize', function () {
         //    b ---- a
         //    |      |
         //    c ---- d
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [2, 2]}),
-                iD.Node({id: 'b', loc: [-2, 2]}),
-                iD.Node({id: 'c', loc: [-2, -2]}),
-                iD.Node({id: 'd', loc: [2, -2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']}),
-                iD.Way({id: '=', nodes: ['d']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [2, 2]}),
+                iD.osmNode({id: 'b', loc: [-2, 2]}),
+                iD.osmNode({id: 'c', loc: [-2, -2]}),
+                iD.osmNode({id: 'd', loc: [2, -2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']}),
+                iD.osmWay({id: '=', nodes: ['d']})
             ]);
 
         graph = iD.actionCircularize('-', projection)(graph);
@@ -113,12 +113,12 @@ describe('iD.actionCircularize', function () {
         //    d ---- c
         //    |      |
         //    a ---- b
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [2, 0]}),
-                iD.Node({id: 'c', loc: [2, 2]}),
-                iD.Node({id: 'd', loc: [0, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [2, 0]}),
+                iD.osmNode({id: 'c', loc: [2, 2]}),
+                iD.osmNode({id: 'd', loc: [0, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
             ]),
             centroid, points;
 
@@ -140,12 +140,12 @@ describe('iD.actionCircularize', function () {
         //    d ---- c
         //    |      |
         //    a ---- b
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [2, 0]}),
-                iD.Node({id: 'c', loc: [2, 2]}),
-                iD.Node({id: 'd', loc: [0, 2]}),
-                iD.Way({id: '+', nodes: ['a', 'd', 'c', 'b', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [2, 0]}),
+                iD.osmNode({id: 'c', loc: [2, 2]}),
+                iD.osmNode({id: 'd', loc: [0, 2]}),
+                iD.osmWay({id: '+', nodes: ['a', 'd', 'c', 'b', 'a']})
             ]);
 
         expect(area('+', graph)).to.be.gt(0);
@@ -160,12 +160,12 @@ describe('iD.actionCircularize', function () {
         //    d ---- c
         //    |      |
         //    a ---- b
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [2, 0]}),
-                iD.Node({id: 'c', loc: [2, 2]}),
-                iD.Node({id: 'd', loc: [0, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [2, 0]}),
+                iD.osmNode({id: 'c', loc: [2, 2]}),
+                iD.osmNode({id: 'd', loc: [0, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
             ]);
 
         expect(area('-', graph)).to.be.lt(0);
@@ -186,16 +186,16 @@ describe('iD.actionCircularize', function () {
         //  a-b-c-d-e-a is counterclockwise
         //  a-b-f-g-e-a is clockwise
         //
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [ 0,  0]}),
-                iD.Node({id: 'b', loc: [ 1,  2]}),
-                iD.Node({id: 'c', loc: [-2,  2]}),
-                iD.Node({id: 'd', loc: [-2, -2]}),
-                iD.Node({id: 'e', loc: [ 1, -2]}),
-                iD.Node({id: 'f', loc: [ 3,  2]}),
-                iD.Node({id: 'g', loc: [ 3, -2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']}),
-                iD.Way({id: '=', nodes: ['a', 'b', 'f', 'g', 'e', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [ 0,  0]}),
+                iD.osmNode({id: 'b', loc: [ 1,  2]}),
+                iD.osmNode({id: 'c', loc: [-2,  2]}),
+                iD.osmNode({id: 'd', loc: [-2, -2]}),
+                iD.osmNode({id: 'e', loc: [ 1, -2]}),
+                iD.osmNode({id: 'f', loc: [ 3,  2]}),
+                iD.osmNode({id: 'g', loc: [ 3, -2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']}),
+                iD.osmWay({id: '=', nodes: ['a', 'b', 'f', 'g', 'e', 'a']})
             ]);
 
         expect(intersection(graph.entity('-').nodes, graph.entity('=').nodes).length).to.eql(3);
@@ -220,16 +220,16 @@ describe('iD.actionCircularize', function () {
         //  a-b-c-d-e-a is counterclockwise
         //  a-e-g-f-b-a is counterclockwise
         //
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [ 0,  0]}),
-                iD.Node({id: 'b', loc: [ 1,  2]}),
-                iD.Node({id: 'c', loc: [-2,  2]}),
-                iD.Node({id: 'd', loc: [-2, -2]}),
-                iD.Node({id: 'e', loc: [ 1, -2]}),
-                iD.Node({id: 'f', loc: [ 3,  2]}),
-                iD.Node({id: 'g', loc: [ 3, -2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']}),
-                iD.Way({id: '=', nodes: ['a', 'e', 'g', 'f', 'b', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [ 0,  0]}),
+                iD.osmNode({id: 'b', loc: [ 1,  2]}),
+                iD.osmNode({id: 'c', loc: [-2,  2]}),
+                iD.osmNode({id: 'd', loc: [-2, -2]}),
+                iD.osmNode({id: 'e', loc: [ 1, -2]}),
+                iD.osmNode({id: 'f', loc: [ 3,  2]}),
+                iD.osmNode({id: 'g', loc: [ 3, -2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']}),
+                iD.osmWay({id: '=', nodes: ['a', 'e', 'g', 'f', 'b', 'a']})
             ]);
 
         expect(intersection(graph.entity('-').nodes, graph.entity('=').nodes).length).to.eql(3);
@@ -253,16 +253,16 @@ describe('iD.actionCircularize', function () {
         //
         //  a-b-c-d-e-a is extremely concave and 'a' is to the left of centoid..
         //
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [ 0,  0]}),
-                iD.Node({id: 'b', loc: [10,  2]}),
-                iD.Node({id: 'c', loc: [-2,  2]}),
-                iD.Node({id: 'd', loc: [-2, -2]}),
-                iD.Node({id: 'e', loc: [10, -2]}),
-                iD.Node({id: 'f', loc: [15,  2]}),
-                iD.Node({id: 'g', loc: [15, -2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']}),
-                iD.Way({id: '=', nodes: ['a', 'b', 'f', 'g', 'e', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [ 0,  0]}),
+                iD.osmNode({id: 'b', loc: [10,  2]}),
+                iD.osmNode({id: 'c', loc: [-2,  2]}),
+                iD.osmNode({id: 'd', loc: [-2, -2]}),
+                iD.osmNode({id: 'e', loc: [10, -2]}),
+                iD.osmNode({id: 'f', loc: [15,  2]}),
+                iD.osmNode({id: 'g', loc: [15, -2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']}),
+                iD.osmWay({id: '=', nodes: ['a', 'b', 'f', 'g', 'e', 'a']})
             ]);
 
         expect(graph.entity('-').isConvex(graph)).to.be.false;
@@ -275,10 +275,10 @@ describe('iD.actionCircularize', function () {
     });
 
     it('circularizes a closed single line way', function () {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [0, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [0, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'a']})
             ]);
 
         expect(area('-', graph)).to.eql(0);
@@ -295,12 +295,12 @@ describe('iD.actionCircularize', function () {
         });
 
         it('circularize at t = 0', function() {
-            var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [2, 0]}),
-                    iD.Node({id: 'c', loc: [2, 2]}),
-                    iD.Node({id: 'd', loc: [0, 2]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [2, 0]}),
+                    iD.osmNode({id: 'c', loc: [2, 2]}),
+                    iD.osmNode({id: 'd', loc: [0, 2]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
                 ]);
             graph = iD.actionCircularize('-', projection)(graph, 0);
             expect(isCircular('-', graph)).to.be.not.ok;
@@ -309,12 +309,12 @@ describe('iD.actionCircularize', function () {
         });
 
         it('circularize at t = 0.5', function() {
-            var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [2, 0]}),
-                    iD.Node({id: 'c', loc: [2, 2]}),
-                    iD.Node({id: 'd', loc: [0, 2]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [2, 0]}),
+                    iD.osmNode({id: 'c', loc: [2, 2]}),
+                    iD.osmNode({id: 'd', loc: [0, 2]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
                 ]);
             graph = iD.actionCircularize('-', projection)(graph, 0.5);
             expect(isCircular('-', graph)).to.be.not.ok;
@@ -323,12 +323,12 @@ describe('iD.actionCircularize', function () {
         });
 
         it('circularize at t = 1', function() {
-            var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [2, 0]}),
-                    iD.Node({id: 'c', loc: [2, 2]}),
-                    iD.Node({id: 'd', loc: [0, 2]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [2, 0]}),
+                    iD.osmNode({id: 'c', loc: [2, 2]}),
+                    iD.osmNode({id: 'd', loc: [0, 2]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
                 ]);
             graph = iD.actionCircularize('-', projection)(graph, 1);
             expect(isCircular('-', graph)).to.be.ok;
diff --git a/test/spec/actions/copy_entities.js b/test/spec/actions/copy_entities.js
index 41f9df127..f6ac256f3 100644
--- a/test/spec/actions/copy_entities.js
+++ b/test/spec/actions/copy_entities.js
@@ -1,7 +1,7 @@
 describe('iD.actionCopyEntities', function () {
     it('copies a node', function () {
-        var a = iD.Node({id: 'a'}),
-            base = iD.Graph([a]),
+        var a = iD.osmNode({id: 'a'}),
+            base = iD.coreGraph([a]),
             head = iD.actionCopyEntities(['a'], base)(base),
             diff = iD.Difference(base, head),
             created = diff.created();
@@ -11,10 +11,10 @@ describe('iD.actionCopyEntities', function () {
     });
 
     it('copies a way', function () {
-        var a = iD.Node({id: 'a'}),
-            b = iD.Node({id: 'b'}),
-            w = iD.Way({id: 'w', nodes: ['a', 'b']}),
-            base = iD.Graph([a, b, w]),
+        var a = iD.osmNode({id: 'a'}),
+            b = iD.osmNode({id: 'b'}),
+            w = iD.osmWay({id: 'w', nodes: ['a', 'b']}),
+            base = iD.coreGraph([a, b, w]),
             action = iD.actionCopyEntities(['w'], base),
             head = action(base),
             diff = iD.Difference(base, head),
@@ -25,9 +25,9 @@ describe('iD.actionCopyEntities', function () {
     });
 
     it('copies multiple nodes', function () {
-        var base = iD.Graph([
-                iD.Node({id: 'a'}),
-                iD.Node({id: 'b'})
+        var base = iD.coreGraph([
+                iD.osmNode({id: 'a'}),
+                iD.osmNode({id: 'b'})
             ]),
             action = iD.actionCopyEntities(['a', 'b'], base),
             head = action(base),
@@ -40,12 +40,12 @@ describe('iD.actionCopyEntities', function () {
     });
 
     it('copies multiple ways, keeping the same connections', function () {
-        var base = iD.Graph([
-                iD.Node({id: 'a'}),
-                iD.Node({id: 'b'}),
-                iD.Node({id: 'c'}),
-                iD.Way({id: 'w1', nodes: ['a', 'b']}),
-                iD.Way({id: 'w2', nodes: ['b', 'c']})
+        var base = iD.coreGraph([
+                iD.osmNode({id: 'a'}),
+                iD.osmNode({id: 'b'}),
+                iD.osmNode({id: 'c'}),
+                iD.osmWay({id: 'w1', nodes: ['a', 'b']}),
+                iD.osmWay({id: 'w2', nodes: ['b', 'c']})
             ]),
             action = iD.actionCopyEntities(['w1', 'w2'], base),
             head = action(base),
@@ -57,9 +57,9 @@ describe('iD.actionCopyEntities', function () {
     });
 
     it('obtains source entities from an alternate graph', function () {
-        var a = iD.Node({id: 'a'}),
-            old = iD.Graph([a]),
-            base = iD.Graph(),
+        var a = iD.osmNode({id: 'a'}),
+            old = iD.coreGraph([a]),
+            base = iD.coreGraph(),
             action = iD.actionCopyEntities(['a'], old),
             head = action(base),
             diff = iD.Difference(base, head);
diff --git a/test/spec/actions/delete_member.js b/test/spec/actions/delete_member.js
index 293999924..72bf13c2d 100644
--- a/test/spec/actions/delete_member.js
+++ b/test/spec/actions/delete_member.js
@@ -1,18 +1,18 @@
 describe('iD.actionDeleteMember', function () {
     it('removes the member at the specified index', function () {
-        var a      = iD.Node({id: 'a'}),
-            b      = iD.Node({id: 'b'}),
-            r      = iD.Relation({members: [{id: 'a'}, {id: 'b'}]}),
+        var a      = iD.osmNode({id: 'a'}),
+            b      = iD.osmNode({id: 'b'}),
+            r      = iD.osmRelation({members: [{id: 'a'}, {id: 'b'}]}),
             action = iD.actionDeleteMember(r.id, 0),
-            graph  = action(iD.Graph([a, b, r]));
+            graph  = action(iD.coreGraph([a, b, r]));
         expect(graph.entity(r.id).members).to.eql([{id: 'b'}]);
     });
 
     it('deletes relations that become degenerate', function () {
-        var a      = iD.Node({id: 'a'}),
-            r      = iD.Relation({id: 'r', members: [{id: 'a'}]}),
+        var a      = iD.osmNode({id: 'a'}),
+            r      = iD.osmRelation({id: 'r', members: [{id: 'a'}]}),
             action = iD.actionDeleteMember(r.id, 0),
-            graph  = action(iD.Graph([a, r]));
+            graph  = action(iD.coreGraph([a, r]));
         expect(graph.hasEntity('r')).to.be.undefined;
     });
 });
diff --git a/test/spec/actions/delete_multiple.js b/test/spec/actions/delete_multiple.js
index 4de9a077c..30270a2b9 100644
--- a/test/spec/actions/delete_multiple.js
+++ b/test/spec/actions/delete_multiple.js
@@ -1,20 +1,20 @@
 describe('iD.actionDeleteMultiple', function () {
     it('deletes multiple entities of heterogeneous types', function () {
-        var n      = iD.Node(),
-            w      = iD.Way(),
-            r      = iD.Relation(),
+        var n      = iD.osmNode(),
+            w      = iD.osmWay(),
+            r      = iD.osmRelation(),
             action = iD.actionDeleteMultiple([n.id, w.id, r.id]),
-            graph  = action(iD.Graph([n, w, r]));
+            graph  = action(iD.coreGraph([n, w, r]));
         expect(graph.hasEntity(n.id)).to.be.undefined;
         expect(graph.hasEntity(w.id)).to.be.undefined;
         expect(graph.hasEntity(r.id)).to.be.undefined;
     });
 
     it('deletes a way and one of its nodes', function () {
-        var n      = iD.Node(),
-            w      = iD.Way({nodes: [n.id]}),
+        var n      = iD.osmNode(),
+            w      = iD.osmWay({nodes: [n.id]}),
             action = iD.actionDeleteMultiple([w.id, n.id]),
-            graph  = action(iD.Graph([n, w]));
+            graph  = action(iD.coreGraph([n, w]));
         expect(graph.hasEntity(w.id)).to.be.undefined;
         expect(graph.hasEntity(n.id)).to.be.undefined;
     });
@@ -22,9 +22,9 @@ describe('iD.actionDeleteMultiple', function () {
     // This was moved to operationDelete.  We should test operations and move this test there.
     // describe('#disabled', function () {
     //     it('returns the result of the first action that is disabled', function () {
-    //         var node     = iD.Node(),
-    //             relation = iD.Relation({members: [{id: 'w'}]}),
-    //             graph    = iD.Graph([node, relation]),
+    //         var node     = iD.osmNode(),
+    //             relation = iD.osmRelation({members: [{id: 'w'}]}),
+    //             graph    = iD.coreGraph([node, relation]),
     //             action   = iD.actionDeleteMultiple([node.id, relation.id]);
     //         expect(action.disabled(graph)).to.equal('incomplete_relation');
     //     });
diff --git a/test/spec/actions/delete_node.js b/test/spec/actions/delete_node.js
index 687b0a972..2e6d99980 100644
--- a/test/spec/actions/delete_node.js
+++ b/test/spec/actions/delete_node.js
@@ -1,53 +1,53 @@
 describe('iD.actionDeleteNode', function () {
     it('removes the node from the graph', function () {
-        var node   = iD.Node(),
+        var node   = iD.osmNode(),
             action = iD.actionDeleteNode(node.id),
-            graph  = action(iD.Graph([node]));
+            graph  = action(iD.coreGraph([node]));
         expect(graph.hasEntity(node.id)).to.be.undefined;
     });
 
     it('removes the node from parent ways', function () {
-        var node1  = iD.Node(),
-            node2  = iD.Node(),
-            node3  = iD.Node(),
-            way    = iD.Way({nodes: [node1.id, node2.id, node3.id]}),
+        var node1  = iD.osmNode(),
+            node2  = iD.osmNode(),
+            node3  = iD.osmNode(),
+            way    = iD.osmWay({nodes: [node1.id, node2.id, node3.id]}),
             action = iD.actionDeleteNode(node1.id),
-            graph  = action(iD.Graph([node1, node2, node3, way]));
+            graph  = action(iD.coreGraph([node1, node2, node3, way]));
         expect(graph.entity(way.id).nodes).to.eql([node2.id, node3.id]);
     });
 
     it('removes the node from parent relations', function () {
-        var node1    = iD.Node(),
-            node2    = iD.Node(),
-            relation = iD.Relation({members: [{ id: node1.id }, { id: node2.id }]}),
+        var node1    = iD.osmNode(),
+            node2    = iD.osmNode(),
+            relation = iD.osmRelation({members: [{ id: node1.id }, { id: node2.id }]}),
             action   = iD.actionDeleteNode(node1.id),
-            graph    = action(iD.Graph([node1, node2, relation]));
+            graph    = action(iD.coreGraph([node1, node2, relation]));
         expect(graph.entity(relation.id).members).to.eql([{ id: node2.id }]);
     });
 
     it('deletes parent ways that would otherwise have less than two nodes', function () {
-        var node1  = iD.Node(),
-            node2  = iD.Node(),
-            way    = iD.Way({nodes: [node1.id, node2.id]}),
+        var node1  = iD.osmNode(),
+            node2  = iD.osmNode(),
+            way    = iD.osmWay({nodes: [node1.id, node2.id]}),
             action = iD.actionDeleteNode(node1.id),
-            graph  = action(iD.Graph([node1, node2, way]));
+            graph  = action(iD.coreGraph([node1, node2, way]));
         expect(graph.hasEntity(way.id)).to.be.undefined;
     });
 
     it('deletes degenerate circular ways', function () {
-        var node1  = iD.Node(),
-            node2  = iD.Node(),
-            way    = iD.Way({nodes: [node1.id, node2.id, node1.id]}),
+        var node1  = iD.osmNode(),
+            node2  = iD.osmNode(),
+            way    = iD.osmWay({nodes: [node1.id, node2.id, node1.id]}),
             action = iD.actionDeleteNode(node2.id),
-            graph  = action(iD.Graph([node1, node2, way]));
+            graph  = action(iD.coreGraph([node1, node2, way]));
         expect(graph.hasEntity(way.id)).to.be.undefined;
     });
 
     it('deletes parent relations that become empty', function () {
-        var node1    = iD.Node(),
-            relation = iD.Relation({members: [{ id: node1.id }]}),
+        var node1    = iD.osmNode(),
+            relation = iD.osmRelation({members: [{ id: node1.id }]}),
             action   = iD.actionDeleteNode(node1.id),
-            graph    = action(iD.Graph([node1, relation]));
+            graph    = action(iD.coreGraph([node1, relation]));
         expect(graph.hasEntity(relation.id)).to.be.undefined;
     });
 });
diff --git a/test/spec/actions/delete_relation.js b/test/spec/actions/delete_relation.js
index acf3fb241..7b8cdd75a 100644
--- a/test/spec/actions/delete_relation.js
+++ b/test/spec/actions/delete_relation.js
@@ -1,92 +1,92 @@
 describe('iD.actionDeleteRelation', function () {
     it('removes the relation from the graph', function () {
-        var relation = iD.Relation(),
+        var relation = iD.osmRelation(),
             action   = iD.actionDeleteRelation(relation.id),
-            graph    = action(iD.Graph([relation]));
+            graph    = action(iD.coreGraph([relation]));
         expect(graph.hasEntity(relation.id)).to.be.undefined;
     });
 
     it('removes the relation from parent relations', function () {
-        var a      = iD.Relation(),
-            b      = iD.Relation(),
-            parent = iD.Relation({members: [{ id: a.id }, { id: b.id }]}),
+        var a      = iD.osmRelation(),
+            b      = iD.osmRelation(),
+            parent = iD.osmRelation({members: [{ id: a.id }, { id: b.id }]}),
             action = iD.actionDeleteRelation(a.id),
-            graph  = action(iD.Graph([a, b, parent]));
+            graph  = action(iD.coreGraph([a, b, parent]));
         expect(graph.entity(parent.id).members).to.eql([{ id: b.id }]);
     });
 
     it('deletes member nodes not referenced by another parent', function() {
-        var node     = iD.Node(),
-            relation = iD.Relation({members: [{id: node.id}]}),
+        var node     = iD.osmNode(),
+            relation = iD.osmRelation({members: [{id: node.id}]}),
             action   = iD.actionDeleteRelation(relation.id),
-            graph    = action(iD.Graph([node, relation]));
+            graph    = action(iD.coreGraph([node, relation]));
         expect(graph.hasEntity(node.id)).to.be.undefined;
     });
 
     it('does not delete member nodes referenced by another parent', function() {
-        var node     = iD.Node(),
-            way      = iD.Way({nodes: [node.id]}),
-            relation = iD.Relation({members: [{id: node.id}]}),
+        var node     = iD.osmNode(),
+            way      = iD.osmWay({nodes: [node.id]}),
+            relation = iD.osmRelation({members: [{id: node.id}]}),
             action   = iD.actionDeleteRelation(relation.id),
-            graph    = action(iD.Graph([node, way, relation]));
+            graph    = action(iD.coreGraph([node, way, relation]));
         expect(graph.hasEntity(node.id)).not.to.be.undefined;
     });
 
     it('does not delete member nodes with interesting tags', function() {
-        var node     = iD.Node({tags: {highway: 'traffic_signals'}}),
-            relation = iD.Relation({members: [{id: node.id}]}),
+        var node     = iD.osmNode({tags: {highway: 'traffic_signals'}}),
+            relation = iD.osmRelation({members: [{id: node.id}]}),
             action   = iD.actionDeleteRelation(relation.id),
-            graph    = action(iD.Graph([node, relation]));
+            graph    = action(iD.coreGraph([node, relation]));
         expect(graph.hasEntity(node.id)).not.to.be.undefined;
     });
 
     it('deletes member ways not referenced by another parent', function() {
-        var way      = iD.Way(),
-            relation = iD.Relation({members: [{id: way.id}]}),
+        var way      = iD.osmWay(),
+            relation = iD.osmRelation({members: [{id: way.id}]}),
             action   = iD.actionDeleteRelation(relation.id),
-            graph    = action(iD.Graph([way, relation]));
+            graph    = action(iD.coreGraph([way, relation]));
         expect(graph.hasEntity(way.id)).to.be.undefined;
     });
 
     it('does not delete member ways referenced by another parent', function() {
-        var way       = iD.Way(),
-            relation1 = iD.Relation({members: [{id: way.id}]}),
-            relation2 = iD.Relation({members: [{id: way.id}]}),
+        var way       = iD.osmWay(),
+            relation1 = iD.osmRelation({members: [{id: way.id}]}),
+            relation2 = iD.osmRelation({members: [{id: way.id}]}),
             action    = iD.actionDeleteRelation(relation1.id),
-            graph     = action(iD.Graph([way, relation1, relation2]));
+            graph     = action(iD.coreGraph([way, relation1, relation2]));
         expect(graph.hasEntity(way.id)).not.to.be.undefined;
     });
 
     it('does not delete member ways with interesting tags', function() {
-        var way      = iD.Node({tags: {highway: 'residential'}}),
-            relation = iD.Relation({members: [{id: way.id}]}),
+        var way      = iD.osmNode({tags: {highway: 'residential'}}),
+            relation = iD.osmRelation({members: [{id: way.id}]}),
             action   = iD.actionDeleteRelation(relation.id),
-            graph    = action(iD.Graph([way, relation]));
+            graph    = action(iD.coreGraph([way, relation]));
         expect(graph.hasEntity(way.id)).not.to.be.undefined;
     });
 
     it('deletes nodes of deleted member ways', function() {
-        var node     = iD.Node(),
-            way      = iD.Way({nodes: [node.id]}),
-            relation = iD.Relation({members: [{id: way.id}]}),
+        var node     = iD.osmNode(),
+            way      = iD.osmWay({nodes: [node.id]}),
+            relation = iD.osmRelation({members: [{id: way.id}]}),
             action   = iD.actionDeleteRelation(relation.id),
-            graph    = action(iD.Graph([node, way, relation]));
+            graph    = action(iD.coreGraph([node, way, relation]));
         expect(graph.hasEntity(node.id)).to.be.undefined;
     });
 
     it('deletes parent relations that become empty', function () {
-        var child  = iD.Relation(),
-            parent = iD.Relation({members: [{ id: child.id }]}),
+        var child  = iD.osmRelation(),
+            parent = iD.osmRelation({members: [{ id: child.id }]}),
             action = iD.actionDeleteRelation(child.id),
-            graph  = action(iD.Graph([child, parent]));
+            graph  = action(iD.coreGraph([child, parent]));
         expect(graph.hasEntity(parent.id)).to.be.undefined;
     });
 
     // This was moved to operationDelete.  We should test operations and move this test there.
     // describe('#disabled', function() {
     //     it('returns \'incomplete_relation\' if the relation is incomplete', function() {
-    //         var relation = iD.Relation({members: [{id: 'w'}]}),
-    //             graph    = iD.Graph([relation]),
+    //         var relation = iD.osmRelation({members: [{id: 'w'}]}),
+    //             graph    = iD.coreGraph([relation]),
     //             action   = iD.actionDeleteRelation(relation.id);
     //         expect(action.disabled(graph)).to.equal('incomplete_relation');
     //     });
diff --git a/test/spec/actions/delete_way.js b/test/spec/actions/delete_way.js
index 97263bafa..5bb44cb7a 100644
--- a/test/spec/actions/delete_way.js
+++ b/test/spec/actions/delete_way.js
@@ -1,99 +1,99 @@
 describe('iD.actionDeleteWay', function() {
     it('removes the way from the graph', function() {
-        var way    = iD.Way(),
+        var way    = iD.osmWay(),
             action = iD.actionDeleteWay(way.id),
-            graph  = iD.Graph([way]).update(action);
+            graph  = iD.coreGraph([way]).update(action);
         expect(graph.hasEntity(way.id)).to.be.undefined;
     });
 
     it('removes a way from parent relations', function() {
-        var way      = iD.Way(),
-            relation = iD.Relation({members: [{ id: way.id }, { id: 'w-2' }]}),
+        var way      = iD.osmWay(),
+            relation = iD.osmRelation({members: [{ id: way.id }, { id: 'w-2' }]}),
             action   = iD.actionDeleteWay(way.id),
-            graph    = iD.Graph([way, relation]).update(action),
+            graph    = iD.coreGraph([way, relation]).update(action),
             ids      = graph.entity(relation.id).members.map(function (m) { return m.id; });
         expect(ids).not.to.contain(way.id);
     });
 
     it('deletes member nodes not referenced by another parent', function() {
-        var node   = iD.Node(),
-            way    = iD.Way({nodes: [node.id]}),
+        var node   = iD.osmNode(),
+            way    = iD.osmWay({nodes: [node.id]}),
             action = iD.actionDeleteWay(way.id),
-            graph  = iD.Graph([node, way]).update(action);
+            graph  = iD.coreGraph([node, way]).update(action);
         expect(graph.hasEntity(node.id)).to.be.undefined;
     });
 
     it('does not delete member nodes referenced by another parent', function() {
-        var node   = iD.Node(),
-            way1   = iD.Way({nodes: [node.id]}),
-            way2   = iD.Way({nodes: [node.id]}),
+        var node   = iD.osmNode(),
+            way1   = iD.osmWay({nodes: [node.id]}),
+            way2   = iD.osmWay({nodes: [node.id]}),
             action = iD.actionDeleteWay(way1.id),
-            graph  = iD.Graph([node, way1, way2]).update(action);
+            graph  = iD.coreGraph([node, way1, way2]).update(action);
         expect(graph.hasEntity(node.id)).not.to.be.undefined;
     });
 
     it('deletes multiple member nodes', function() {
-        var a      = iD.Node(),
-            b      = iD.Node(),
-            way    = iD.Way({nodes: [a.id, b.id]}),
+        var a      = iD.osmNode(),
+            b      = iD.osmNode(),
+            way    = iD.osmWay({nodes: [a.id, b.id]}),
             action = iD.actionDeleteWay(way.id),
-            graph  = iD.Graph([a, b, way]).update(action);
+            graph  = iD.coreGraph([a, b, way]).update(action);
         expect(graph.hasEntity(a.id)).to.be.undefined;
         expect(graph.hasEntity(b.id)).to.be.undefined;
     });
 
     it('deletes a circular way\'s start/end node', function() {
-        var a      = iD.Node(),
-            b      = iD.Node(),
-            c      = iD.Node(),
-            way    = iD.Way({nodes: [a.id, b.id, c.id, a.id]}),
+        var a      = iD.osmNode(),
+            b      = iD.osmNode(),
+            c      = iD.osmNode(),
+            way    = iD.osmWay({nodes: [a.id, b.id, c.id, a.id]}),
             action = iD.actionDeleteWay(way.id),
-            graph  = iD.Graph([a, b, c, way]).update(action);
+            graph  = iD.coreGraph([a, b, c, way]).update(action);
         expect(graph.hasEntity(a.id)).to.be.undefined;
         expect(graph.hasEntity(b.id)).to.be.undefined;
         expect(graph.hasEntity(c.id)).to.be.undefined;
     });
 
     it('does not delete member nodes with interesting tags', function() {
-        var node   = iD.Node({tags: {highway: 'traffic_signals'}}),
-            way    = iD.Way({nodes: [node.id]}),
+        var node   = iD.osmNode({tags: {highway: 'traffic_signals'}}),
+            way    = iD.osmWay({nodes: [node.id]}),
             action = iD.actionDeleteWay(way.id),
-            graph  = iD.Graph([node, way]).update(action);
+            graph  = iD.coreGraph([node, way]).update(action);
         expect(graph.hasEntity(node.id)).not.to.be.undefined;
     });
 
     it('deletes parent relations that become empty', function () {
-        var way      = iD.Way(),
-            relation = iD.Relation({members: [{ id: way.id }]}),
+        var way      = iD.osmWay(),
+            relation = iD.osmRelation({members: [{ id: way.id }]}),
             action   = iD.actionDeleteWay(way.id),
-            graph    = iD.Graph([way, relation]).update(action);
+            graph    = iD.coreGraph([way, relation]).update(action);
         expect(graph.hasEntity(relation.id)).to.be.undefined;
     });
 
     // This was moved to operationDelete.  We should test operations and move this test there.
     // describe('#disabled', function () {
     //     it('returns \'part_of_relation\' for members of route and boundary relations', function () {
-    //         var a        = iD.Way({id: 'a'}),
-    //             b        = iD.Way({id: 'b'}),
-    //             route    = iD.Relation({members: [{id: 'a'}], tags: {type: 'route'}}),
-    //             boundary = iD.Relation({members: [{id: 'b'}], tags: {type: 'boundary'}}),
-    //             graph    = iD.Graph([a, b, route, boundary]);
+    //         var a        = iD.osmWay({id: 'a'}),
+    //             b        = iD.osmWay({id: 'b'}),
+    //             route    = iD.osmRelation({members: [{id: 'a'}], tags: {type: 'route'}}),
+    //             boundary = iD.osmRelation({members: [{id: 'b'}], tags: {type: 'boundary'}}),
+    //             graph    = iD.coreGraph([a, b, route, boundary]);
     //         expect(iD.actionDeleteWay('a').disabled(graph)).to.equal('part_of_relation');
     //         expect(iD.actionDeleteWay('b').disabled(graph)).to.equal('part_of_relation');
     //     });
 
     //     it('returns \'part_of_relation\' for outer members of multipolygons', function () {
-    //         var way      = iD.Way({id: 'w'}),
-    //             relation = iD.Relation({members: [{id: 'w', role: 'outer'}], tags: {type: 'multipolygon'}}),
-    //             graph    = iD.Graph([way, relation]),
+    //         var way      = iD.osmWay({id: 'w'}),
+    //             relation = iD.osmRelation({members: [{id: 'w', role: 'outer'}], tags: {type: 'multipolygon'}}),
+    //             graph    = iD.coreGraph([way, relation]),
     //             action   = iD.actionDeleteWay(way.id);
     //         expect(action.disabled(graph)).to.equal('part_of_relation');
     //     });
 
     //     it('returns falsy for inner members of multipolygons', function () {
-    //         var way      = iD.Way({id: 'w'}),
-    //             relation = iD.Relation({members: [{id: 'w', role: 'inner'}], tags: {type: 'multipolygon'}}),
-    //             graph    = iD.Graph([way, relation]),
+    //         var way      = iD.osmWay({id: 'w'}),
+    //             relation = iD.osmRelation({members: [{id: 'w', role: 'inner'}], tags: {type: 'multipolygon'}}),
+    //             graph    = iD.coreGraph([way, relation]),
     //             action   = iD.actionDeleteWay(way.id);
     //         expect(action.disabled(graph)).not.ok;
     //     });
diff --git a/test/spec/actions/disconnect.js b/test/spec/actions/disconnect.js
index 2d3bb98e3..a985933d0 100644
--- a/test/spec/actions/disconnect.js
+++ b/test/spec/actions/disconnect.js
@@ -1,7 +1,7 @@
 describe('iD.actionDisconnect', function () {
     describe('#disabled', function () {
         it('returns \'not_connected\' for a node shared by less than two ways', function () {
-            var graph = iD.Graph([iD.Node({id: 'a'})]);
+            var graph = iD.coreGraph([iD.osmNode({id: 'a'})]);
             expect(iD.actionDisconnect('a').disabled(graph)).to.equal('not_connected');
         });
 
@@ -9,12 +9,12 @@ describe('iD.actionDisconnect', function () {
             //    a ---- b
             //    |      |
             //    d ---- c
-            var graph = iD.Graph([
-                iD.Node({id: 'a'}),
-                iD.Node({id: 'b'}),
-                iD.Node({id: 'c'}),
-                iD.Node({id: 'd'}),
-                iD.Way({id: 'w', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a'}),
+                iD.osmNode({id: 'b'}),
+                iD.osmNode({id: 'c'}),
+                iD.osmNode({id: 'd'}),
+                iD.osmWay({id: 'w', nodes: ['a', 'b', 'c', 'd', 'a']})
             ]);
             expect(iD.actionDisconnect('a').disabled(graph)).not.to.be.ok;
         });
@@ -23,12 +23,12 @@ describe('iD.actionDisconnect', function () {
             //    a ---- b
             //    |      |
             //    d ---- c
-            var graph = iD.Graph([
-                iD.Node({id: 'a'}),
-                iD.Node({id: 'b'}),
-                iD.Node({id: 'c'}),
-                iD.Node({id: 'd'}),
-                iD.Way({id: 'w', nodes: ['a', 'b', 'c', 'd', 'a'], tags: {area: 'yes'}})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a'}),
+                iD.osmNode({id: 'b'}),
+                iD.osmNode({id: 'c'}),
+                iD.osmNode({id: 'd'}),
+                iD.osmWay({id: 'w', nodes: ['a', 'b', 'c', 'd', 'a'], tags: {area: 'yes'}})
             ]);
             expect(iD.actionDisconnect('a').disabled(graph)).to.equal('not_connected');
         });
@@ -37,13 +37,13 @@ describe('iD.actionDisconnect', function () {
             //    a --- b --- c
             //          |     |
             //          e --- d
-            var graph = iD.Graph([
-                    iD.Node({id: 'a'}),
-                    iD.Node({id: 'b'}),
-                    iD.Node({id: 'c'}),
-                    iD.Node({id: 'd'}),
-                    iD.Node({id: 'e'}),
-                    iD.Way({id: 'w', nodes: ['a', 'b', 'c', 'd', 'e', 'b', 'a'], tags: {area: 'yes'}})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a'}),
+                    iD.osmNode({id: 'b'}),
+                    iD.osmNode({id: 'c'}),
+                    iD.osmNode({id: 'd'}),
+                    iD.osmNode({id: 'e'}),
+                    iD.osmWay({id: 'w', nodes: ['a', 'b', 'c', 'd', 'e', 'b', 'a'], tags: {area: 'yes'}})
             ]);
 
             expect(iD.actionDisconnect('b').disabled(graph)).not.to.be.ok;
@@ -53,13 +53,13 @@ describe('iD.actionDisconnect', function () {
             //    a ---- b ---- c
             //           |
             //           d
-            var graph = iD.Graph([
-                    iD.Node({id: 'a'}),
-                    iD.Node({id: 'b'}),
-                    iD.Node({id: 'c'}),
-                    iD.Node({id: 'd'}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c']}),
-                    iD.Way({id: '|', nodes: ['d', 'b']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a'}),
+                    iD.osmNode({id: 'b'}),
+                    iD.osmNode({id: 'c'}),
+                    iD.osmNode({id: 'd'}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c']}),
+                    iD.osmWay({id: '|', nodes: ['d', 'b']})
                 ]);
 
             expect(iD.actionDisconnect('b').disabled(graph)).not.to.be.ok;
@@ -69,13 +69,13 @@ describe('iD.actionDisconnect', function () {
             //    a ---- b ---- c
             //           |
             //           d
-            var graph = iD.Graph([
-                    iD.Node({id: 'a'}),
-                    iD.Node({id: 'b'}),
-                    iD.Node({id: 'c'}),
-                    iD.Node({id: 'd'}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c']}),
-                    iD.Way({id: '|', nodes: ['d', 'b']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a'}),
+                    iD.osmNode({id: 'b'}),
+                    iD.osmNode({id: 'c'}),
+                    iD.osmNode({id: 'd'}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c']}),
+                    iD.osmWay({id: '|', nodes: ['d', 'b']})
             ]);
 
             expect(iD.actionDisconnect('b', ['|']).disabled(graph)).not.to.be.ok;
@@ -84,13 +84,13 @@ describe('iD.actionDisconnect', function () {
         it('returns \'relation\' for a node connecting any two members of the same relation', function () {
             // Covers restriction relations, routes, multipolygons.
             // a ---- b ---- c
-            var graph = iD.Graph([
-                iD.Node({id: 'a'}),
-                iD.Node({id: 'b'}),
-                iD.Node({id: 'c'}),
-                iD.Way({id: 'f', nodes: ['a', 'b']}),
-                iD.Way({id: 't', nodes: ['b', 'c']}),
-                iD.Relation({id: 'r', members: [
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a'}),
+                iD.osmNode({id: 'b'}),
+                iD.osmNode({id: 'c'}),
+                iD.osmWay({id: 'f', nodes: ['a', 'b']}),
+                iD.osmWay({id: 't', nodes: ['b', 'c']}),
+                iD.osmRelation({id: 'r', members: [
                     { id: 'f' },
                     { id: 't' }
                 ]})
@@ -104,15 +104,15 @@ describe('iD.actionDisconnect', function () {
             //        |
             //        d
 
-            var graph = iD.Graph([
-                iD.Node({id: 'a'}),
-                iD.Node({id: 'b'}),
-                iD.Node({id: 'c'}),
-                iD.Node({id: 'd'}),
-                iD.Way({id: 'f', nodes: ['a', 'b']}),
-                iD.Way({id: 't', nodes: ['b', 'c']}),
-                iD.Way({id: '|', nodes: ['b', 'd']}),
-                iD.Relation({id: 'r', members: [
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a'}),
+                iD.osmNode({id: 'b'}),
+                iD.osmNode({id: 'c'}),
+                iD.osmNode({id: 'd'}),
+                iD.osmWay({id: 'f', nodes: ['a', 'b']}),
+                iD.osmWay({id: 't', nodes: ['b', 'c']}),
+                iD.osmWay({id: '|', nodes: ['b', 'd']}),
+                iD.osmRelation({id: 'r', members: [
                     { id: 'f' },
                     { id: 't' }
                 ]})
@@ -136,13 +136,13 @@ describe('iD.actionDisconnect', function () {
         //           |
         //           d
         //
-        var graph = iD.Graph([
-                iD.Node({id: 'a'}),
-                iD.Node({id: 'b'}),
-                iD.Node({id: 'c'}),
-                iD.Node({id: 'd'}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c']}),
-                iD.Way({id: '|', nodes: ['d', 'b']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a'}),
+                iD.osmNode({id: 'b'}),
+                iD.osmNode({id: 'c'}),
+                iD.osmNode({id: 'd'}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c']}),
+                iD.osmWay({id: '|', nodes: ['d', 'b']})
             ]);
 
         graph = iD.actionDisconnect('b', 'e')(graph);
@@ -163,14 +163,14 @@ describe('iD.actionDisconnect', function () {
         //               |
         //               d
         //
-        var graph = iD.Graph([
-                iD.Node({id: 'a'}),
-                iD.Node({id: 'b'}),
-                iD.Node({id: 'c'}),
-                iD.Node({id: 'd'}),
-                iD.Way({id: '-', nodes: ['a', 'b']}),
-                iD.Way({id: '=', nodes: ['b', 'c']}),
-                iD.Way({id: '|', nodes: ['d', 'b']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a'}),
+                iD.osmNode({id: 'b'}),
+                iD.osmNode({id: 'c'}),
+                iD.osmNode({id: 'd'}),
+                iD.osmWay({id: '-', nodes: ['a', 'b']}),
+                iD.osmWay({id: '=', nodes: ['b', 'c']}),
+                iD.osmWay({id: '|', nodes: ['d', 'b']})
             ]);
 
         graph = iD.actionDisconnect('b', 'e').limitWays(['-'])(graph);
@@ -193,11 +193,11 @@ describe('iD.actionDisconnect', function () {
         //        |
         //  d --- c
         //
-        var graph = iD.Graph([
-                iD.Node({id: 'a'}),
-                iD.Node({id: 'b'}),
-                iD.Node({id: 'c'}),
-                iD.Way({id: 'w', nodes: ['a', 'b', 'c', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a'}),
+                iD.osmNode({id: 'b'}),
+                iD.osmNode({id: 'c'}),
+                iD.osmWay({id: 'w', nodes: ['a', 'b', 'c', 'a']})
             ]);
         graph = iD.actionDisconnect('a', 'd')(graph);
         expect(graph.entity('w').nodes).to.eql(['a', 'b', 'c', 'd']);
@@ -218,14 +218,14 @@ describe('iD.actionDisconnect', function () {
         //           e -- d
         // 2 ways a-b  and  *-c-d-e-*
         //
-        var graph = iD.Graph([
-            iD.Node({id: 'a'}),
-            iD.Node({id: 'b'}),
-            iD.Node({id: 'c'}),
-            iD.Node({id: 'd'}),
-            iD.Node({id: 'e'}),
-            iD.Way({id: 'w1', nodes: ['a', 'b']}),
-            iD.Way({id: 'w2', nodes: ['b', 'c', 'd', 'e', 'b']})
+        var graph = iD.coreGraph([
+            iD.osmNode({id: 'a'}),
+            iD.osmNode({id: 'b'}),
+            iD.osmNode({id: 'c'}),
+            iD.osmNode({id: 'd'}),
+            iD.osmNode({id: 'e'}),
+            iD.osmWay({id: 'w1', nodes: ['a', 'b']}),
+            iD.osmWay({id: 'w2', nodes: ['b', 'c', 'd', 'e', 'b']})
         ]);
 
         graph = iD.actionDisconnect('b', '*')(graph);
@@ -247,13 +247,13 @@ describe('iD.actionDisconnect', function () {
         //  |         |
         //  * -- e -- d
         //
-        var graph = iD.Graph([
-            iD.Node({id: 'a'}),
-            iD.Node({id: 'b'}),
-            iD.Node({id: 'c'}),
-            iD.Node({id: 'd'}),
-            iD.Node({id: 'e'}),
-            iD.Way({id: 'w', nodes: ['a', 'b', 'c', 'd', 'e', 'b', 'a'], tags: {area: 'yes'}})
+        var graph = iD.coreGraph([
+            iD.osmNode({id: 'a'}),
+            iD.osmNode({id: 'b'}),
+            iD.osmNode({id: 'c'}),
+            iD.osmNode({id: 'd'}),
+            iD.osmNode({id: 'e'}),
+            iD.osmWay({id: 'w', nodes: ['a', 'b', 'c', 'd', 'e', 'b', 'a'], tags: {area: 'yes'}})
         ]);
 
         graph = iD.actionDisconnect('b', '*')(graph);
@@ -278,14 +278,14 @@ describe('iD.actionDisconnect', function () {
         //    c         e
         // 2 areas: a-b-c-a  and  *-d-e-*
 
-        var graph = iD.Graph([
-            iD.Node({id: 'a'}),
-            iD.Node({id: 'b'}),
-            iD.Node({id: 'c'}),
-            iD.Node({id: 'd'}),
-            iD.Node({id: 'e'}),
-            iD.Way({id: 'w1', nodes: ['a', 'b', 'c', 'a'], tags: {area: 'yes'}}),
-            iD.Way({id: 'w2', nodes: ['b', 'd', 'e', 'b'], tags: {area: 'yes'}})
+        var graph = iD.coreGraph([
+            iD.osmNode({id: 'a'}),
+            iD.osmNode({id: 'b'}),
+            iD.osmNode({id: 'c'}),
+            iD.osmNode({id: 'd'}),
+            iD.osmNode({id: 'e'}),
+            iD.osmWay({id: 'w1', nodes: ['a', 'b', 'c', 'a'], tags: {area: 'yes'}}),
+            iD.osmWay({id: 'w2', nodes: ['b', 'd', 'e', 'b'], tags: {area: 'yes'}})
         ]);
 
         graph = iD.actionDisconnect('b', '*')(graph);
@@ -311,14 +311,14 @@ describe('iD.actionDisconnect', function () {
         //    c         e
         // 2 areas: b-c-a-b  and  *-d-e-*
 
-        var graph = iD.Graph([
-            iD.Node({id: 'a'}),
-            iD.Node({id: 'b'}),
-            iD.Node({id: 'c'}),
-            iD.Node({id: 'd'}),
-            iD.Node({id: 'e'}),
-            iD.Way({id: 'w1', nodes: ['b', 'c', 'a', 'b'], tags: {area: 'yes'}}),
-            iD.Way({id: 'w2', nodes: ['b', 'd', 'e', 'b'], tags: {area: 'yes'}})
+        var graph = iD.coreGraph([
+            iD.osmNode({id: 'a'}),
+            iD.osmNode({id: 'b'}),
+            iD.osmNode({id: 'c'}),
+            iD.osmNode({id: 'd'}),
+            iD.osmNode({id: 'e'}),
+            iD.osmWay({id: 'w1', nodes: ['b', 'c', 'a', 'b'], tags: {area: 'yes'}}),
+            iD.osmWay({id: 'w2', nodes: ['b', 'd', 'e', 'b'], tags: {area: 'yes'}})
         ]);
 
         graph = iD.actionDisconnect('b', '*')(graph);
@@ -330,13 +330,13 @@ describe('iD.actionDisconnect', function () {
     it('copies location and tags to the new nodes', function () {
         var tags  = {highway: 'traffic_signals'},
             loc   = [1, 2],
-            graph = iD.Graph([
-                iD.Node({id: 'a'}),
-                iD.Node({id: 'b', loc: loc, tags: tags}),
-                iD.Node({id: 'c'}),
-                iD.Node({id: 'd'}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c']}),
-                iD.Way({id: '|', nodes: ['d', 'b']})
+            graph = iD.coreGraph([
+                iD.osmNode({id: 'a'}),
+                iD.osmNode({id: 'b', loc: loc, tags: tags}),
+                iD.osmNode({id: 'c'}),
+                iD.osmNode({id: 'd'}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c']}),
+                iD.osmWay({id: '|', nodes: ['d', 'b']})
             ]);
 
         graph = iD.actionDisconnect('b', 'e')(graph);
diff --git a/test/spec/actions/merge.js b/test/spec/actions/merge.js
index dc3d27059..0c80063ea 100644
--- a/test/spec/actions/merge.js
+++ b/test/spec/actions/merge.js
@@ -1,10 +1,10 @@
 describe('iD.actionMerge', function () {
     it('merges multiple points to a line', function () {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', tags: {a: 'a'}}),
-                iD.Node({id: 'b', tags: {b: 'b'}}),
-                iD.Way({id: 'w'}),
-                iD.Relation({id: 'r', members: [{id: 'a', role: 'r', type: 'node'}]})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', tags: {a: 'a'}}),
+                iD.osmNode({id: 'b', tags: {b: 'b'}}),
+                iD.osmWay({id: 'w'}),
+                iD.osmRelation({id: 'r', members: [{id: 'a', role: 'r', type: 'node'}]})
             ]),
             action = iD.actionMerge(['a', 'b', 'w']);
 
@@ -19,11 +19,11 @@ describe('iD.actionMerge', function () {
     });
 
     it('merges multiple points to an area', function () {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', tags: {a: 'a'}}),
-                iD.Node({id: 'b', tags: {b: 'b'}}),
-                iD.Way({id: 'w', tags: {area: 'yes'}}),
-                iD.Relation({id: 'r', members: [{id: 'a', role: 'r', type: 'node'}]})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', tags: {a: 'a'}}),
+                iD.osmNode({id: 'b', tags: {b: 'b'}}),
+                iD.osmWay({id: 'w', tags: {area: 'yes'}}),
+                iD.osmRelation({id: 'r', members: [{id: 'a', role: 'r', type: 'node'}]})
             ]),
             action = iD.actionMerge(['a', 'b', 'w']);
 
@@ -38,11 +38,11 @@ describe('iD.actionMerge', function () {
     });
 
     it('preserves original point if possible', function () {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [1, 0], tags: {a: 'a'}}),
-                iD.Node({id: 'p', loc: [0, 0], tags: {p: 'p'}}),
-                iD.Node({id: 'q', loc: [0, 1]}),
-                iD.Way({id: 'w', nodes: ['p', 'q'], tags: {w: 'w'}})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [1, 0], tags: {a: 'a'}}),
+                iD.osmNode({id: 'p', loc: [0, 0], tags: {p: 'p'}}),
+                iD.osmNode({id: 'q', loc: [0, 1]}),
+                iD.osmWay({id: 'w', nodes: ['p', 'q'], tags: {w: 'w'}})
             ]),
             action = iD.actionMerge(['a', 'w']);
 
diff --git a/test/spec/actions/merge_polygon.js b/test/spec/actions/merge_polygon.js
index c787d3906..d3f7e0f4f 100644
--- a/test/spec/actions/merge_polygon.js
+++ b/test/spec/actions/merge_polygon.js
@@ -1,11 +1,11 @@
 describe('iD.actionMergePolygon', function () {
 
     function node(id, x, y) {
-        e.push(iD.Node({ id: id, loc: [x, y] }));
+        e.push(iD.osmNode({ id: id, loc: [x, y] }));
     }
 
     function way(id, nodes) {
-        e.push(iD.Way({ id: id, nodes: nodes.map(function(n) { return 'n' + n; }) }));
+        e.push(iD.osmWay({ id: id, nodes: nodes.map(function(n) { return 'n' + n; }) }));
     }
 
     var e = [];
@@ -41,7 +41,7 @@ describe('iD.actionMergePolygon', function () {
     var graph;
 
     beforeEach(function() {
-        graph = iD.Graph(e);
+        graph = iD.coreGraph(e);
     });
 
     function find(relation, id) {
@@ -84,9 +84,9 @@ describe('iD.actionMergePolygon', function () {
     });
 
     it('merges multipolygon tags', function() {
-        var graph = iD.Graph([
-            iD.Relation({id: 'r1', tags: {type: 'multipolygon', a: 'a'}}),
-            iD.Relation({id: 'r2', tags: {type: 'multipolygon', b: 'b'}})
+        var graph = iD.coreGraph([
+            iD.osmRelation({id: 'r1', tags: {type: 'multipolygon', a: 'a'}}),
+            iD.osmRelation({id: 'r2', tags: {type: 'multipolygon', b: 'b'}})
         ]);
 
         graph = iD.actionMergePolygon(['r1', 'r2'])(graph);
@@ -105,8 +105,8 @@ describe('iD.actionMergePolygon', function () {
     it('merges no tags from unclosed outer ways', function() {
         graph = graph.replace(graph.entity('w3').update({ tags: { 'natural': 'water' }}));
 
-        var r1 = iD.Relation({id: 'r1', tags: {type: 'multipolygon'}});
-        var r2 = iD.Relation({id: 'r2', tags: {type: 'multipolygon'},
+        var r1 = iD.osmRelation({id: 'r1', tags: {type: 'multipolygon'}});
+        var r2 = iD.osmRelation({id: 'r2', tags: {type: 'multipolygon'},
             members: [
                 { type: 'way', role: 'outer', id: 'w3' },
                 { type: 'way', role: 'outer', id: 'w4' }
@@ -149,7 +149,7 @@ describe('iD.actionMergePolygon', function () {
     });
 
     it('extends a multipolygon with multi-way rings', function() {
-        var r = iD.Relation({ id: 'r', tags: { type: 'multipolygon' }, members: [
+        var r = iD.osmRelation({ id: 'r', tags: { type: 'multipolygon' }, members: [
             { type: 'way', role: 'outer', id: 'w0' },
             { type: 'way', role: 'inner', id: 'w3' },
             { type: 'way', role: 'inner', id: 'w4' }
diff --git a/test/spec/actions/merge_remote_changes.js b/test/spec/actions/merge_remote_changes.js
index 51cd60173..33835d971 100644
--- a/test/spec/actions/merge_remote_changes.js
+++ b/test/spec/actions/merge_remote_changes.js
@@ -1,30 +1,30 @@
 describe('iD.actionMergeRemoteChanges', function () {
-    var base = iD.Graph([
-            iD.Node({id: 'a', loc: [1, 1], version: '1', tags: {foo: 'foo'}}),
+    var base = iD.coreGraph([
+            iD.osmNode({id: 'a', loc: [1, 1], version: '1', tags: {foo: 'foo'}}),
 
-            iD.Node({id: 'p1', loc: [ 10,  10], version: '1'}),
-            iD.Node({id: 'p2', loc: [ 10, -10], version: '1'}),
-            iD.Node({id: 'p3', loc: [-10, -10], version: '1'}),
-            iD.Node({id: 'p4', loc: [-10,  10], version: '1'}),
-            iD.Way({
+            iD.osmNode({id: 'p1', loc: [ 10,  10], version: '1'}),
+            iD.osmNode({id: 'p2', loc: [ 10, -10], version: '1'}),
+            iD.osmNode({id: 'p3', loc: [-10, -10], version: '1'}),
+            iD.osmNode({id: 'p4', loc: [-10,  10], version: '1'}),
+            iD.osmWay({
                 id: 'w1',
                 nodes: ['p1', 'p2', 'p3', 'p4', 'p1'],
                 version: '1',
                 tags: {foo: 'foo', area: 'yes'}
             }),
 
-            iD.Node({id: 'q1', loc: [ 5,  5], version: '1'}),
-            iD.Node({id: 'q2', loc: [ 5, -5], version: '1'}),
-            iD.Node({id: 'q3', loc: [-5, -5], version: '1'}),
-            iD.Node({id: 'q4', loc: [-5,  5], version: '1'}),
-            iD.Way({
+            iD.osmNode({id: 'q1', loc: [ 5,  5], version: '1'}),
+            iD.osmNode({id: 'q2', loc: [ 5, -5], version: '1'}),
+            iD.osmNode({id: 'q3', loc: [-5, -5], version: '1'}),
+            iD.osmNode({id: 'q4', loc: [-5,  5], version: '1'}),
+            iD.osmWay({
                 id: 'w2',
                 nodes: ['q1', 'q2', 'q3', 'q4', 'q1'],
                 version: '1',
                 tags: {foo: 'foo', area: 'yes'}
             }),
 
-            iD.Relation({
+            iD.osmRelation({
                 id: 'r',
                 members: [{id: 'w1', role: 'outer'}, {id: 'w2', role: 'inner'}],
                 version: '1',
@@ -33,22 +33,22 @@ describe('iD.actionMergeRemoteChanges', function () {
         ]),
 
         // some new objects not in the graph yet..
-        r1 = iD.Node({id: 'r1', loc: [ 12,  12], version: '1'}),
-        r2 = iD.Node({id: 'r2', loc: [ 12, -12], version: '1'}),
-        r3 = iD.Node({id: 'r3', loc: [-12, -12], version: '1'}),
-        r4 = iD.Node({id: 'r4', loc: [-12,  12], version: '1'}),
-        w3 = iD.Way({
+        r1 = iD.osmNode({id: 'r1', loc: [ 12,  12], version: '1'}),
+        r2 = iD.osmNode({id: 'r2', loc: [ 12, -12], version: '1'}),
+        r3 = iD.osmNode({id: 'r3', loc: [-12, -12], version: '1'}),
+        r4 = iD.osmNode({id: 'r4', loc: [-12,  12], version: '1'}),
+        w3 = iD.osmWay({
                 id: 'w3',
                 nodes: ['r1', 'r2', 'r3', 'r4', 'r1'],
                 version: '1',
                 tags: {foo: 'foo_new', area: 'yes'}
             }),
 
-        s1 = iD.Node({id: 's1', loc: [ 6,  6], version: '1'}),
-        s2 = iD.Node({id: 's2', loc: [ 6, -6], version: '1'}),
-        s3 = iD.Node({id: 's3', loc: [-6, -6], version: '1'}),
-        s4 = iD.Node({id: 's4', loc: [-6,  6], version: '1'}),
-        w4 = iD.Way({
+        s1 = iD.osmNode({id: 's1', loc: [ 6,  6], version: '1'}),
+        s2 = iD.osmNode({id: 's2', loc: [ 6, -6], version: '1'}),
+        s3 = iD.osmNode({id: 's3', loc: [-6, -6], version: '1'}),
+        s4 = iD.osmNode({id: 's4', loc: [-6,  6], version: '1'}),
+        w4 = iD.osmWay({
                 id: 'w4',
                 nodes: ['s1', 's2', 's3', 's4', 's1'],
                 version: '1',
@@ -59,7 +59,7 @@ describe('iD.actionMergeRemoteChanges', function () {
     function makeGraph(entities) {
         return entities.reduce(function(graph, entity) {
             return graph.replace(entity);
-        }, iD.Graph(base));
+        }, iD.coreGraph(base));
     }
 
 
diff --git a/test/spec/actions/move.js b/test/spec/actions/move.js
index 554a44d35..c2777248a 100644
--- a/test/spec/actions/move.js
+++ b/test/spec/actions/move.js
@@ -4,34 +4,34 @@ describe('iD.actionMove', function() {
     // This was moved to operationMove.  We should test operations and move this test there.
     // describe('#disabled', function() {
     //     it('returns falsy by default', function() {
-    //         var node  = iD.Node({loc: [0, 0]}),
+    //         var node  = iD.osmNode({loc: [0, 0]}),
     //             action = iD.actionMove([node.id], [0, 0], projection),
-    //             graph = iD.Graph([node]);
+    //             graph = iD.coreGraph([node]);
     //         expect(action.disabled(graph)).not.to.be.ok;
     //     });
 
     //     it('returns \'incomplete_relation\' for an incomplete relation', function() {
-    //         var relation = iD.Relation({members: [{id: 1}]}),
+    //         var relation = iD.osmRelation({members: [{id: 1}]}),
     //             action = iD.actionMove([relation.id], [0, 0], projection),
-    //             graph = iD.Graph([relation]);
+    //             graph = iD.coreGraph([relation]);
     //         expect(action.disabled(graph)).to.equal('incomplete_relation');
     //     });
 
     //     it('returns falsy for a complete relation', function() {
-    //         var node  = iD.Node({loc: [0, 0]}),
-    //             relation = iD.Relation({members: [{id: node.id}]}),
+    //         var node  = iD.osmNode({loc: [0, 0]}),
+    //             relation = iD.osmRelation({members: [{id: node.id}]}),
     //             action = iD.actionMove([relation.id], [0, 0], projection),
-    //             graph = iD.Graph([node, relation]);
+    //             graph = iD.coreGraph([node, relation]);
     //         expect(action.disabled(graph)).not.to.be.ok;
     //     });
     // });
 
     it('moves all nodes in a way by the given amount', function() {
-        var node1  = iD.Node({loc: [0, 0]}),
-            node2  = iD.Node({loc: [5, 10]}),
-            way    = iD.Way({nodes: [node1.id, node2.id]}),
+        var node1  = iD.osmNode({loc: [0, 0]}),
+            node2  = iD.osmNode({loc: [5, 10]}),
+            way    = iD.osmWay({nodes: [node1.id, node2.id]}),
             delta  = [2, 3],
-            graph  = iD.actionMove([way.id], delta, projection)(iD.Graph([node1, node2, way])),
+            graph  = iD.actionMove([way.id], delta, projection)(iD.coreGraph([node1, node2, way])),
             loc1   = graph.entity(node1.id).loc,
             loc2   = graph.entity(node2.id).loc;
         expect(loc1[0]).to.be.closeTo( 1.440, 0.001);
@@ -41,32 +41,32 @@ describe('iD.actionMove', function() {
     });
 
     it('moves repeated nodes only once', function() {
-        var node   = iD.Node({loc: [0, 0]}),
-            way    = iD.Way({nodes: [node.id, node.id]}),
+        var node   = iD.osmNode({loc: [0, 0]}),
+            way    = iD.osmWay({nodes: [node.id, node.id]}),
             delta  = [2, 3],
-            graph  = iD.actionMove([way.id], delta, projection)(iD.Graph([node, way])),
+            graph  = iD.actionMove([way.id], delta, projection)(iD.coreGraph([node, way])),
             loc    = graph.entity(node.id).loc;
         expect(loc[0]).to.be.closeTo( 1.440, 0.001);
         expect(loc[1]).to.be.closeTo(-2.159, 0.001);
     });
 
     it('moves multiple ways', function() {
-        var node   = iD.Node({loc: [0, 0]}),
-            way1   = iD.Way({nodes: [node.id]}),
-            way2   = iD.Way({nodes: [node.id]}),
+        var node   = iD.osmNode({loc: [0, 0]}),
+            way1   = iD.osmWay({nodes: [node.id]}),
+            way2   = iD.osmWay({nodes: [node.id]}),
             delta  = [2, 3],
-            graph  = iD.actionMove([way1.id, way2.id], delta, projection)(iD.Graph([node, way1, way2])),
+            graph  = iD.actionMove([way1.id, way2.id], delta, projection)(iD.coreGraph([node, way1, way2])),
             loc    = graph.entity(node.id).loc;
         expect(loc[0]).to.be.closeTo( 1.440, 0.001);
         expect(loc[1]).to.be.closeTo(-2.159, 0.001);
     });
 
     it('moves leaf nodes of a relation', function() {
-        var node     = iD.Node({loc: [0, 0]}),
-            way      = iD.Way({nodes: [node.id]}),
-            relation = iD.Relation({members: [{id: way.id}]}),
+        var node     = iD.osmNode({loc: [0, 0]}),
+            way      = iD.osmWay({nodes: [node.id]}),
+            relation = iD.osmRelation({members: [{id: way.id}]}),
             delta    = [2, 3],
-            graph    = iD.actionMove([relation.id], delta, projection)(iD.Graph([node, way, relation])),
+            graph    = iD.actionMove([relation.id], delta, projection)(iD.coreGraph([node, way, relation])),
             loc      = graph.entity(node.id).loc;
         expect(loc[0]).to.be.closeTo( 1.440, 0.001);
         expect(loc[1]).to.be.closeTo(-2.159, 0.001);
diff --git a/test/spec/actions/noop.js b/test/spec/actions/noop.js
index d8f5df850..fcace8b0c 100644
--- a/test/spec/actions/noop.js
+++ b/test/spec/actions/noop.js
@@ -1,6 +1,6 @@
 describe('iD.actionNoop', function () {
     it('does nothing', function () {
-        var graph = iD.Graph(),
+        var graph = iD.coreGraph(),
             action = iD.actionNoop(graph);
         expect(action(graph)).to.equal(graph);
     });
diff --git a/test/spec/actions/orthogonalize.js b/test/spec/actions/orthogonalize.js
index d3fb8946d..5da57ef8a 100644
--- a/test/spec/actions/orthogonalize.js
+++ b/test/spec/actions/orthogonalize.js
@@ -2,12 +2,12 @@ describe('iD.actionOrthogonalize', function () {
     var projection = d3.geoMercator();
 
     it('orthogonalizes a perfect quad', function () {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [2, 0]}),
-                iD.Node({id: 'c', loc: [2, 2]}),
-                iD.Node({id: 'd', loc: [0, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [2, 0]}),
+                iD.osmNode({id: 'c', loc: [2, 2]}),
+                iD.osmNode({id: 'd', loc: [0, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
             ]);
 
         graph = iD.actionOrthogonalize('-', projection)(graph);
@@ -15,12 +15,12 @@ describe('iD.actionOrthogonalize', function () {
     });
 
     it('orthogonalizes a quad', function () {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [4, 0]}),
-                iD.Node({id: 'c', loc: [3, 2]}),
-                iD.Node({id: 'd', loc: [0, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [4, 0]}),
+                iD.osmNode({id: 'c', loc: [3, 2]}),
+                iD.osmNode({id: 'd', loc: [0, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
             ]);
 
         graph = iD.actionOrthogonalize('-', projection)(graph);
@@ -28,11 +28,11 @@ describe('iD.actionOrthogonalize', function () {
     });
 
     it('orthogonalizes a triangle', function () {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [3, 0]}),
-                iD.Node({id: 'c', loc: [2, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [3, 0]}),
+                iD.osmNode({id: 'c', loc: [2, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'a']})
             ]);
 
         graph = iD.actionOrthogonalize('-', projection)(graph);
@@ -40,13 +40,13 @@ describe('iD.actionOrthogonalize', function () {
     });
 
     it('deletes empty redundant nodes', function() {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [2, 0]}),
-                iD.Node({id: 'c', loc: [2, 2]}),
-                iD.Node({id: 'd', loc: [1, 2]}),
-                iD.Node({id: 'e', loc: [0, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [2, 0]}),
+                iD.osmNode({id: 'c', loc: [2, 2]}),
+                iD.osmNode({id: 'd', loc: [1, 2]}),
+                iD.osmNode({id: 'e', loc: [0, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']})
             ]);
 
         graph = iD.actionOrthogonalize('-', projection)(graph);
@@ -54,13 +54,13 @@ describe('iD.actionOrthogonalize', function () {
     });
 
     it('preserves non empty redundant nodes', function() {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [2, 0]}),
-                iD.Node({id: 'c', loc: [2, 2]}),
-                iD.Node({id: 'd', loc: [1, 2], tags: {foo: 'bar'}}),
-                iD.Node({id: 'e', loc: [0, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [2, 0]}),
+                iD.osmNode({id: 'c', loc: [2, 2]}),
+                iD.osmNode({id: 'd', loc: [1, 2], tags: {foo: 'bar'}}),
+                iD.osmNode({id: 'e', loc: [0, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'a']})
             ]);
 
         graph = iD.actionOrthogonalize('-', projection)(graph);
@@ -85,12 +85,12 @@ describe('iD.actionOrthogonalize', function () {
         ];
 
         for (var i = 0; i < tests.length; i++) {
-            var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: tests[i][0]}),
-                    iD.Node({id: 'b', loc: tests[i][1]}),
-                    iD.Node({id: 'c', loc: tests[i][2]}),
-                    iD.Node({id: 'd', loc: tests[i][3]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: tests[i][0]}),
+                    iD.osmNode({id: 'b', loc: tests[i][1]}),
+                    iD.osmNode({id: 'c', loc: tests[i][2]}),
+                    iD.osmNode({id: 'd', loc: tests[i][3]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
                 ]),
                 initialWidth = iD.geoSphericalDistance(graph.entity('a').loc, graph.entity('b').loc),
                 finalWidth;
@@ -103,14 +103,14 @@ describe('iD.actionOrthogonalize', function () {
     });
 
     it('only moves nodes which are near right or near straight', function() {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [3, 0.001]}),
-                iD.Node({id: 'c', loc: [3, 1]}),
-                iD.Node({id: 'd', loc: [2, 1]}),
-                iD.Node({id: 'e', loc: [1, 2]}),
-                iD.Node({id: 'f', loc: [0, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [3, 0.001]}),
+                iD.osmNode({id: 'c', loc: [3, 1]}),
+                iD.osmNode({id: 'd', loc: [2, 1]}),
+                iD.osmNode({id: 'e', loc: [1, 2]}),
+                iD.osmNode({id: 'f', loc: [0, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'a']})
             ]),
             diff = iD.Difference(graph, iD.actionOrthogonalize('-', projection)(graph));
 
@@ -124,14 +124,14 @@ describe('iD.actionOrthogonalize', function () {
         });
 
         it('orthogonalize at t = 0', function() {
-           var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
-                    iD.Node({id: 'c', loc: [2, -0.01]}),
-                    iD.Node({id: 'd', loc: [3, 0]}),
-                    iD.Node({id: 'e', loc: [3, 1]}),
-                    iD.Node({id: 'f', loc: [0, 1]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'a']})
+           var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
+                    iD.osmNode({id: 'c', loc: [2, -0.01]}),
+                    iD.osmNode({id: 'd', loc: [3, 0]}),
+                    iD.osmNode({id: 'e', loc: [3, 1]}),
+                    iD.osmNode({id: 'f', loc: [0, 1]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'a']})
                 ]);
 
             graph = iD.actionOrthogonalize('-', projection)(graph, 0);
@@ -144,14 +144,14 @@ describe('iD.actionOrthogonalize', function () {
         });
 
         it('orthogonalize at t = 0.5', function() {
-           var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
-                    iD.Node({id: 'c', loc: [2, -0.01]}),
-                    iD.Node({id: 'd', loc: [3, 0]}),
-                    iD.Node({id: 'e', loc: [3, 1]}),
-                    iD.Node({id: 'f', loc: [0, 1]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'a']})
+           var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
+                    iD.osmNode({id: 'c', loc: [2, -0.01]}),
+                    iD.osmNode({id: 'd', loc: [3, 0]}),
+                    iD.osmNode({id: 'e', loc: [3, 1]}),
+                    iD.osmNode({id: 'f', loc: [0, 1]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'a']})
                 ]);
 
             graph = iD.actionOrthogonalize('-', projection)(graph, 0.5);
@@ -163,14 +163,14 @@ describe('iD.actionOrthogonalize', function () {
         });
 
         it('orthogonalize at t = 1', function() {
-           var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
-                    iD.Node({id: 'c', loc: [2, -0.01]}),
-                    iD.Node({id: 'd', loc: [3, 0]}),
-                    iD.Node({id: 'e', loc: [3, 1]}),
-                    iD.Node({id: 'f', loc: [0, 1]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'a']})
+           var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
+                    iD.osmNode({id: 'c', loc: [2, -0.01]}),
+                    iD.osmNode({id: 'd', loc: [3, 0]}),
+                    iD.osmNode({id: 'e', loc: [3, 1]}),
+                    iD.osmNode({id: 'f', loc: [0, 1]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'a']})
                 ]);
 
             graph = iD.actionOrthogonalize('-', projection)(graph, 1);
diff --git a/test/spec/actions/reflect.js b/test/spec/actions/reflect.js
index c06737129..6ed75f422 100644
--- a/test/spec/actions/reflect.js
+++ b/test/spec/actions/reflect.js
@@ -2,12 +2,12 @@ describe('iD.actionReflect', function() {
     var projection = d3.geoMercator();
 
     it('does not create or remove nodes', function () {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [4, 0]}),
-                iD.Node({id: 'c', loc: [4, 2]}),
-                iD.Node({id: 'd', loc: [1, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [4, 0]}),
+                iD.osmNode({id: 'c', loc: [4, 2]}),
+                iD.osmNode({id: 'd', loc: [1, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
             ]);
         graph = iD.actionReflect(['-'], projection)(graph);
         expect(graph.entity('-').nodes).to.have.length(5);
@@ -20,12 +20,12 @@ describe('iD.actionReflect', function() {
         //   /     |  ->   \     |
         //  a ---- b        d -- c
         //
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [4, 0]}),
-                iD.Node({id: 'c', loc: [4, 2]}),
-                iD.Node({id: 'd', loc: [1, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [4, 0]}),
+                iD.osmNode({id: 'c', loc: [4, 2]}),
+                iD.osmNode({id: 'd', loc: [1, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
             ]);
         graph = iD.actionReflect(['-'], projection)(graph);
         expect(graph.entity('a').loc[0]).to.be.closeTo(0, 1e-6);
@@ -45,12 +45,12 @@ describe('iD.actionReflect', function() {
         //   /     |  ->  |     \
         //  a ---- b      b ---- a
         //
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [4, 0]}),
-                iD.Node({id: 'c', loc: [4, 2]}),
-                iD.Node({id: 'd', loc: [1, 2]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [4, 0]}),
+                iD.osmNode({id: 'c', loc: [4, 2]}),
+                iD.osmNode({id: 'd', loc: [1, 2]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
             ]);
         graph = iD.actionReflect(['-'], projection).useLongAxis(false)(graph);
         expect(graph.entity('a').loc[0]).to.be.closeTo(4, 1e-6);
@@ -70,12 +70,12 @@ describe('iD.actionReflect', function() {
         });
 
         it('reflect long at t = 0', function() {
-            var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [4, 0]}),
-                    iD.Node({id: 'c', loc: [4, 2]}),
-                    iD.Node({id: 'd', loc: [1, 2]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [4, 0]}),
+                    iD.osmNode({id: 'c', loc: [4, 2]}),
+                    iD.osmNode({id: 'd', loc: [1, 2]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
                 ]);
             graph = iD.actionReflect(['-'], projection)(graph, 0);
             expect(graph.entity('a').loc[0]).to.be.closeTo(0, 1e-6);
@@ -89,12 +89,12 @@ describe('iD.actionReflect', function() {
         });
 
         it('reflect long at t = 0.5', function() {
-            var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [4, 0]}),
-                    iD.Node({id: 'c', loc: [4, 2]}),
-                    iD.Node({id: 'd', loc: [1, 2]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [4, 0]}),
+                    iD.osmNode({id: 'c', loc: [4, 2]}),
+                    iD.osmNode({id: 'd', loc: [1, 2]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
                 ]);
             graph = iD.actionReflect(['-'], projection)(graph, 0.5);
             expect(graph.entity('a').loc[0]).to.be.closeTo(0, 1e-6);
@@ -108,12 +108,12 @@ describe('iD.actionReflect', function() {
         });
 
         it('reflect long at t = 1', function() {
-            var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [4, 0]}),
-                    iD.Node({id: 'c', loc: [4, 2]}),
-                    iD.Node({id: 'd', loc: [1, 2]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [4, 0]}),
+                    iD.osmNode({id: 'c', loc: [4, 2]}),
+                    iD.osmNode({id: 'd', loc: [1, 2]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
                 ]);
             graph = iD.actionReflect(['-'], projection)(graph, 1);
             expect(graph.entity('a').loc[0]).to.be.closeTo(0, 1e-6);
@@ -127,12 +127,12 @@ describe('iD.actionReflect', function() {
         });
 
         it('reflect short at t = 0', function() {
-            var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [4, 0]}),
-                    iD.Node({id: 'c', loc: [4, 2]}),
-                    iD.Node({id: 'd', loc: [1, 2]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [4, 0]}),
+                    iD.osmNode({id: 'c', loc: [4, 2]}),
+                    iD.osmNode({id: 'd', loc: [1, 2]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
                 ]);
             graph = iD.actionReflect(['-'], projection).useLongAxis(false)(graph, 0);
             expect(graph.entity('a').loc[0]).to.be.closeTo(0, 1e-6);
@@ -146,12 +146,12 @@ describe('iD.actionReflect', function() {
         });
 
         it('reflect short at t = 0.5', function() {
-            var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [4, 0]}),
-                    iD.Node({id: 'c', loc: [4, 2]}),
-                    iD.Node({id: 'd', loc: [1, 2]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [4, 0]}),
+                    iD.osmNode({id: 'c', loc: [4, 2]}),
+                    iD.osmNode({id: 'd', loc: [1, 2]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
                 ]);
             graph = iD.actionReflect(['-'], projection).useLongAxis(false)(graph, 0.5);
             expect(graph.entity('a').loc[0]).to.be.closeTo(2, 1e-6);
@@ -165,12 +165,12 @@ describe('iD.actionReflect', function() {
         });
 
         it('reflect short at t = 1', function() {
-            var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [4, 0]}),
-                    iD.Node({id: 'c', loc: [4, 2]}),
-                    iD.Node({id: 'd', loc: [1, 2]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [4, 0]}),
+                    iD.osmNode({id: 'c', loc: [4, 2]}),
+                    iD.osmNode({id: 'd', loc: [1, 2]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd', 'a']})
                 ]);
             graph = iD.actionReflect(['-'], projection).useLongAxis(false)(graph, 1);
             expect(graph.entity('a').loc[0]).to.be.closeTo(4, 1e-6);
diff --git a/test/spec/actions/revert.js b/test/spec/actions/revert.js
index 7d4156194..3433d9bf7 100644
--- a/test/spec/actions/revert.js
+++ b/test/spec/actions/revert.js
@@ -1,25 +1,25 @@
 describe('iD.actionRevert', function() {
     describe('basic', function () {
         it('removes a new entity', function() {
-            var n1 = iD.Node({id: 'n-1'}),
-                graph = iD.Graph().replace(n1);
+            var n1 = iD.osmNode({id: 'n-1'}),
+                graph = iD.coreGraph().replace(n1);
 
             graph = iD.actionRevert('n-1')(graph);
             expect(graph.hasEntity('n-1')).to.be.undefined;
         });
 
         it('reverts an updated entity', function() {
-            var n1 = iD.Node({id: 'n1'}),
+            var n1 = iD.osmNode({id: 'n1'}),
                 n1up = n1.update({}),
-                graph = iD.Graph([n1]).replace(n1up);
+                graph = iD.coreGraph([n1]).replace(n1up);
 
             graph = iD.actionRevert('n1')(graph);
             expect(graph.hasEntity('n1')).to.equal(n1);
         });
 
         it('restores a deleted entity', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                graph = iD.Graph([n1]).remove(n1);
+            var n1 = iD.osmNode({id: 'n1'}),
+                graph = iD.coreGraph([n1]).remove(n1);
 
             graph = iD.actionRevert('n1')(graph);
             expect(graph.hasEntity('n1')).to.equal(n1);
@@ -29,12 +29,12 @@ describe('iD.actionRevert', function() {
     describe('reverting way child nodes', function () {
         it('removes new node, updates parent way nodelist', function() {
             // note: test with a 3 node way so w1 doesnt go degenerate..
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n2'}),
-                n3 = iD.Node({id: 'n-3'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n1', 'n2']}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n2'}),
+                n3 = iD.osmNode({id: 'n-3'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n1', 'n2']}),
                 w1up = w1.addNode('n-3', 2),
-                graph = iD.Graph([n1, n2, w1]).replace(n3).replace(w1up);
+                graph = iD.coreGraph([n1, n2, w1]).replace(n3).replace(w1up);
 
             graph = iD.actionRevert('n-3')(graph);
 
@@ -48,11 +48,11 @@ describe('iD.actionRevert', function() {
         });
 
         it('reverts existing node, preserves parent way nodelist', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n2'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n1', 'n2']}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n2'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n1', 'n2']}),
                 n1up = n1.update({}),
-                graph = iD.Graph([n1, n2, w1]).replace(n1up);
+                graph = iD.coreGraph([n1, n2, w1]).replace(n1up);
 
             graph = iD.actionRevert('n1')(graph);
 
@@ -67,11 +67,11 @@ describe('iD.actionRevert', function() {
 
     describe('reverting relation members', function () {
         it('removes new node, updates parent relation memberlist', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n-2'}),
-                r1 = iD.Relation({id: 'r1', members: [{id: 'n1'}]}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n-2'}),
+                r1 = iD.osmRelation({id: 'r1', members: [{id: 'n1'}]}),
                 r1up = r1.addMember({id: 'n-2'}, 1),
-                graph = iD.Graph([n1, r1]).replace(n2).replace(r1up);
+                graph = iD.coreGraph([n1, r1]).replace(n2).replace(r1up);
 
             graph = iD.actionRevert('n-2')(graph);
 
@@ -83,11 +83,11 @@ describe('iD.actionRevert', function() {
         });
 
         it('reverts existing node, preserves parent relation memberlist', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n2'}),
-                r1 = iD.Relation({id: 'r1', members: [{id: 'n1'}, {id: 'n2'}]}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n2'}),
+                r1 = iD.osmRelation({id: 'r1', members: [{id: 'n1'}, {id: 'n2'}]}),
                 n1up = n1.update({}),
-                graph = iD.Graph([n1, n2, r1]).replace(n1up);
+                graph = iD.coreGraph([n1, n2, r1]).replace(n1up);
 
             graph = iD.actionRevert('n1')(graph);
 
@@ -102,10 +102,10 @@ describe('iD.actionRevert', function() {
 
     describe('reverting parent ways', function () {
         it('removes new way, preserves new and existing child nodes', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n-2'}),
-                w1 = iD.Way({id: 'w-1', nodes: ['n1', 'n-2']}),
-                graph = iD.Graph([n1]).replace(n2).replace(w1);
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n-2'}),
+                w1 = iD.osmWay({id: 'w-1', nodes: ['n1', 'n-2']}),
+                graph = iD.coreGraph([n1]).replace(n2).replace(w1);
 
             graph = iD.actionRevert('w-1')(graph);
             expect(graph.hasEntity('w-1'), 'w-1 removed').to.be.undefined;
@@ -116,11 +116,11 @@ describe('iD.actionRevert', function() {
         });
 
         it('reverts an updated way, preserves new and existing child nodes', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n-2'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n1']}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n-2'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n1']}),
                 w1up = w1.addNode('n-2', 1),
-                graph = iD.Graph([n1, w1]).replace(n2).replace(w1up);
+                graph = iD.coreGraph([n1, w1]).replace(n2).replace(w1up);
 
             graph = iD.actionRevert('w1')(graph);
             expect(graph.hasEntity('w1'), 'w1 reverted').to.equal(w1);
@@ -131,11 +131,11 @@ describe('iD.actionRevert', function() {
         });
 
         it('restores a deleted way, preserves new and existing child nodes', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n-2'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n1']}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n-2'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n1']}),
                 w1up = w1.addNode('n-2', 1),
-                graph = iD.Graph([n1, w1]).replace(n2).replace(w1up).remove(w1up);
+                graph = iD.coreGraph([n1, w1]).replace(n2).replace(w1up).remove(w1up);
 
             graph = iD.actionRevert('w1')(graph);
             expect(graph.hasEntity('w1'), 'w1 reverted').to.equal(w1);
@@ -148,10 +148,10 @@ describe('iD.actionRevert', function() {
 
     describe('reverting parent relations', function () {
         it('removes new relation, preserves new and existing members', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n-2'}),
-                r1 = iD.Relation({id: 'r-1', members: [{id: 'n1'}, {id: 'n-2'}]}),
-                graph = iD.Graph([n1]).replace(n2).replace(r1);
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n-2'}),
+                r1 = iD.osmRelation({id: 'r-1', members: [{id: 'n1'}, {id: 'n-2'}]}),
+                graph = iD.coreGraph([n1]).replace(n2).replace(r1);
 
             graph = iD.actionRevert('r-1')(graph);
             expect(graph.hasEntity('r-1'), 'r-1 removed').to.be.undefined;
@@ -162,11 +162,11 @@ describe('iD.actionRevert', function() {
         });
 
         it('reverts an updated relation, preserves new and existing members', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n-2'}),
-                r1 = iD.Relation({id: 'r1', members: [{id: 'n1'}]}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n-2'}),
+                r1 = iD.osmRelation({id: 'r1', members: [{id: 'n1'}]}),
                 r1up = r1.addMember({id: 'n-2'}, 1),
-                graph = iD.Graph([n1, r1]).replace(n2).replace(r1up);
+                graph = iD.coreGraph([n1, r1]).replace(n2).replace(r1up);
 
             graph = iD.actionRevert('r1')(graph);
             expect(graph.hasEntity('r1'), 'r1 reverted').to.equal(r1);
@@ -177,11 +177,11 @@ describe('iD.actionRevert', function() {
         });
 
         it('restores a deleted relation, preserves new and existing members', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n-2'}),
-                r1 = iD.Relation({id: 'r1', members: [{id: 'n1'}]}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n-2'}),
+                r1 = iD.osmRelation({id: 'r1', members: [{id: 'n1'}]}),
                 r1up = r1.addMember({id: 'n-2'}, 1),
-                graph = iD.Graph([n1, r1]).replace(n2).replace(r1up).remove(r1up);
+                graph = iD.coreGraph([n1, r1]).replace(n2).replace(r1up).remove(r1up);
 
             graph = iD.actionRevert('r1')(graph);
             expect(graph.hasEntity('r1'), 'r1 reverted').to.equal(r1);
diff --git a/test/spec/actions/straighten.js b/test/spec/actions/straighten.js
index e9c63ed4f..30d2d58bf 100644
--- a/test/spec/actions/straighten.js
+++ b/test/spec/actions/straighten.js
@@ -3,34 +3,34 @@ describe('iD.actionStraighten', function () {
 
     describe('#disabled', function () {
         it('returns falsy for ways with internal nodes near centerline', function () {
-            var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [1, 0.01]}),
-                iD.Node({id: 'c', loc: [2, 0]}),
-                iD.Node({id: 'd', loc: [3, 0]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [1, 0.01]}),
+                iD.osmNode({id: 'c', loc: [2, 0]}),
+                iD.osmNode({id: 'd', loc: [3, 0]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd']})
             ]);
             expect(iD.actionStraighten('-', projection).disabled(graph)).not.to.be.ok;
         });
 
         it('returns \'too_bendy\' for ways with internal nodes far off centerline', function () {
-            var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [1, 1]}),
-                iD.Node({id: 'c', loc: [2, 0]}),
-                iD.Node({id: 'd', loc: [3, 0]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [1, 1]}),
+                iD.osmNode({id: 'c', loc: [2, 0]}),
+                iD.osmNode({id: 'd', loc: [3, 0]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd']})
             ]);
             expect(iD.actionStraighten('-', projection).disabled(graph)).to.equal('too_bendy');
         });
 
         it('returns \'too_bendy\' for ways with coincident start/end nodes', function () {
-            var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [1, 0]}),
-                iD.Node({id: 'c', loc: [2, 0]}),
-                iD.Node({id: 'd', loc: [0, 0]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [1, 0]}),
+                iD.osmNode({id: 'c', loc: [2, 0]}),
+                iD.osmNode({id: 'd', loc: [0, 0]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd']})
             ]);
             expect(iD.actionStraighten('-', projection).disabled(graph)).to.equal('too_bendy');
         });
@@ -38,11 +38,11 @@ describe('iD.actionStraighten', function () {
 
 
     it('deletes empty nodes', function() {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [1, 0.01], tags: {}}),
-                iD.Node({id: 'c', loc: [2, 0]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [1, 0.01], tags: {}}),
+                iD.osmNode({id: 'c', loc: [2, 0]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c']})
             ]);
 
         graph = iD.actionStraighten('-', projection)(graph);
@@ -51,11 +51,11 @@ describe('iD.actionStraighten', function () {
     });
 
     it('does not delete tagged nodes', function() {
-       var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
-                iD.Node({id: 'c', loc: [2, 0]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c']})
+       var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
+                iD.osmNode({id: 'c', loc: [2, 0]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c']})
             ]);
 
         graph = iD.actionStraighten('-', projection)(graph);
@@ -65,12 +65,12 @@ describe('iD.actionStraighten', function () {
     });
 
     it('does not delete nodes connected to other ways', function() {
-        var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0, 0]}),
-                iD.Node({id: 'b', loc: [1, 0.01]}),
-                iD.Node({id: 'c', loc: [2, 0]}),
-                iD.Way({id: '-', nodes: ['a', 'b', 'c']}),
-                iD.Way({id: '=', nodes: ['b']})
+        var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0, 0]}),
+                iD.osmNode({id: 'b', loc: [1, 0.01]}),
+                iD.osmNode({id: 'c', loc: [2, 0]}),
+                iD.osmWay({id: '-', nodes: ['a', 'b', 'c']}),
+                iD.osmWay({id: '=', nodes: ['b']})
             ]);
 
         graph = iD.actionStraighten('-', projection)(graph);
@@ -86,12 +86,12 @@ describe('iD.actionStraighten', function () {
         });
 
         it('straighten at t = 0', function() {
-           var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
-                    iD.Node({id: 'c', loc: [2, -0.01]}),
-                    iD.Node({id: 'd', loc: [3, 0]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd']})
+           var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
+                    iD.osmNode({id: 'c', loc: [2, -0.01]}),
+                    iD.osmNode({id: 'd', loc: [3, 0]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd']})
                 ]);
 
             graph = iD.actionStraighten('-', projection)(graph, 0);
@@ -103,12 +103,12 @@ describe('iD.actionStraighten', function () {
         });
 
         it('straighten at t = 0.5', function() {
-           var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
-                    iD.Node({id: 'c', loc: [2, -0.01]}),
-                    iD.Node({id: 'd', loc: [3, 0]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd']})
+           var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
+                    iD.osmNode({id: 'c', loc: [2, -0.01]}),
+                    iD.osmNode({id: 'd', loc: [3, 0]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd']})
                 ]);
 
             graph = iD.actionStraighten('-', projection)(graph, 0.5);
@@ -120,12 +120,12 @@ describe('iD.actionStraighten', function () {
         });
 
         it('straighten at t = 1', function() {
-           var graph = iD.Graph([
-                    iD.Node({id: 'a', loc: [0, 0]}),
-                    iD.Node({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
-                    iD.Node({id: 'c', loc: [2, -0.01]}),
-                    iD.Node({id: 'd', loc: [3, 0]}),
-                    iD.Way({id: '-', nodes: ['a', 'b', 'c', 'd']})
+           var graph = iD.coreGraph([
+                    iD.osmNode({id: 'a', loc: [0, 0]}),
+                    iD.osmNode({id: 'b', loc: [1, 0.01], tags: {foo: 'bar'}}),
+                    iD.osmNode({id: 'c', loc: [2, -0.01]}),
+                    iD.osmNode({id: 'd', loc: [3, 0]}),
+                    iD.osmWay({id: '-', nodes: ['a', 'b', 'c', 'd']})
                 ]);
 
             graph = iD.actionStraighten('-', projection)(graph, 1);
diff --git a/test/spec/behavior/hash.js b/test/spec/behavior/hash.js
index 2c4d4f04f..683ec0b69 100644
--- a/test/spec/behavior/hash.js
+++ b/test/spec/behavior/hash.js
@@ -4,7 +4,7 @@ describe('iD.behaviorHash', function () {
     var hash, context;
 
     beforeEach(function () {
-        context = iD.Context();
+        context = iD.coreContext();
         var container = d3.select(document.createElement('div'));
         context.container(container);
         container.call(context.map());
diff --git a/test/spec/behavior/lasso.js b/test/spec/behavior/lasso.js
index a4331efb7..56b4be6e6 100644
--- a/test/spec/behavior/lasso.js
+++ b/test/spec/behavior/lasso.js
@@ -2,7 +2,7 @@ describe('iD.behaviorLasso', function () {
     var context, lasso;
 
     beforeEach(function () {
-        context = iD.Context();
+        context = iD.coreContext();
         d3.select(document.createElement('div'))
             .attr('id', 'map')
             .call(context.map());
diff --git a/test/spec/behavior/select.js b/test/spec/behavior/select.js
index 7771ebd89..4994ca01b 100644
--- a/test/spec/behavior/select.js
+++ b/test/spec/behavior/select.js
@@ -3,10 +3,10 @@ describe('iD.behaviorSelect', function() {
 
     beforeEach(function() {
         container = d3.select('body').append('div');
-        context = iD.Context().container(container);
+        context = iD.coreContext().container(container);
 
-        a = iD.Node({loc: [0, 0]});
-        b = iD.Node({loc: [0, 0]});
+        a = iD.osmNode({loc: [0, 0]});
+        b = iD.osmNode({loc: [0, 0]});
 
         context.perform(iD.actionAddEntity(a), iD.actionAddEntity(b));
 
diff --git a/test/spec/core/context.js b/test/spec/core/context.js
index 3d7a5a175..a481aabbe 100644
--- a/test/spec/core/context.js
+++ b/test/spec/core/context.js
@@ -1,11 +1,11 @@
-describe('iD.Context', function() {
+describe('iD.coreContext', function() {
     var assets = {
         'iD/img/loader.gif': '/assets/iD/img/loader-b66184b5c4afbccc25f.gif'
     };
 
     describe('#assetPath', function() {
         it('sets and gets assetPath', function() {
-            var context = iD.Context();
+            var context = iD.coreContext();
             expect(context.assetPath()).to.eql('');
 
             context.assetPath('iD/');
@@ -15,7 +15,7 @@ describe('iD.Context', function() {
 
     describe('#assetMap', function() {
         it('sets and gets assetMap', function() {
-            var context = iD.Context();
+            var context = iD.coreContext();
             expect(context.assetMap()).to.eql({});
 
             context.assetMap(assets);
@@ -26,7 +26,7 @@ describe('iD.Context', function() {
     describe('#asset', function() {
         var context;
         beforeEach(function() {
-            context = iD.Context().assetPath('iD/').assetMap(assets);
+            context = iD.coreContext().assetPath('iD/').assetMap(assets);
         });
 
         it('looks first in assetMap', function() {
@@ -40,7 +40,7 @@ describe('iD.Context', function() {
     describe('#imagePath', function() {
         var context;
         beforeEach(function() {
-            context = iD.Context().assetPath('iD/').assetMap(assets);
+            context = iD.coreContext().assetPath('iD/').assetMap(assets);
         });
 
         it('looks first in assetMap', function() {
@@ -53,7 +53,7 @@ describe('iD.Context', function() {
 
     describe('#debug', function() {
         it('sets and gets debug flags', function() {
-            var context = iD.Context(),
+            var context = iD.coreContext(),
                 flags = {
                     tile: false,
                     collision: false,
diff --git a/test/spec/core/difference.js b/test/spec/core/difference.js
index 623387e5c..97ca0eaaf 100644
--- a/test/spec/core/difference.js
+++ b/test/spec/core/difference.js
@@ -1,92 +1,92 @@
 describe('iD.Difference', function () {
     describe('#changes', function () {
         it('includes created entities', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph(),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph(),
                 head = base.replace(node),
                 diff = iD.Difference(base, head);
             expect(diff.changes()).to.eql({n: {base: undefined, head: node}});
         });
 
         it('includes undone created entities', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph(),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph(),
                 head = base.replace(node),
                 diff = iD.Difference(head, base);
             expect(diff.changes()).to.eql({n: {base: node, head: undefined}});
         });
 
         it('includes modified entities', function () {
-            var n1 = iD.Node({id: 'n'}),
+            var n1 = iD.osmNode({id: 'n'}),
                 n2 = n1.update({ tags: { yes: 'no' } }),
-                base = iD.Graph([n1]),
+                base = iD.coreGraph([n1]),
                 head = base.replace(n2),
                 diff = iD.Difference(base, head);
             expect(diff.changes()).to.eql({n: {base: n1, head: n2}});
         });
 
         it('includes undone modified entities', function () {
-            var n1 = iD.Node({id: 'n'}),
+            var n1 = iD.osmNode({id: 'n'}),
                 n2 = n1.update({ tags: { yes: 'no' } }),
-                base = iD.Graph([n1]),
+                base = iD.coreGraph([n1]),
                 head = base.replace(n2),
                 diff = iD.Difference(head, base);
             expect(diff.changes()).to.eql({n: {base: n2, head: n1}});
         });
 
         it('doesn\'t include updated but identical entities', function () {
-            var n1 = iD.Node({id: 'n'}),
+            var n1 = iD.osmNode({id: 'n'}),
                 n2 = n1.update(),
-                base = iD.Graph([n1]),
+                base = iD.coreGraph([n1]),
                 head = base.replace(n2),
                 diff = iD.Difference(base, head);
             expect(diff.changes()).to.eql({});
         });
 
         it('includes deleted entities', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph([node]),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph([node]),
                 head = base.remove(node),
                 diff = iD.Difference(base, head);
             expect(diff.changes()).to.eql({n: {base: node, head: undefined}});
         });
 
         it('includes undone deleted entities', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph([node]),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph([node]),
                 head = base.remove(node),
                 diff = iD.Difference(head, base);
             expect(diff.changes()).to.eql({n: {base: undefined, head: node}});
         });
 
         it('doesn\'t include created entities that were subsequently deleted', function () {
-            var node = iD.Node(),
-                base = iD.Graph(),
+            var node = iD.osmNode(),
+                base = iD.coreGraph(),
                 head = base.replace(node).remove(node),
                 diff = iD.Difference(base, head);
             expect(diff.changes()).to.eql({});
         });
 
         it('doesn\'t include created entities that were subsequently reverted', function () {
-            var node = iD.Node({id: 'n-1'}),
-                base = iD.Graph(),
+            var node = iD.osmNode({id: 'n-1'}),
+                base = iD.coreGraph(),
                 head = base.replace(node).revert('n-1'),
                 diff = iD.Difference(base, head);
             expect(diff.changes()).to.eql({});
         });
 
         it('doesn\'t include modified entities that were subsequently reverted', function () {
-            var n1 = iD.Node({id: 'n'}),
+            var n1 = iD.osmNode({id: 'n'}),
                 n2 = n1.update({ tags: { yes: 'no' } }),
-                base = iD.Graph([n1]),
+                base = iD.coreGraph([n1]),
                 head = base.replace(n2).revert('n'),
                 diff = iD.Difference(base, head);
             expect(diff.changes()).to.eql({});
         });
 
         it('doesn\'t include deleted entities that were subsequently reverted', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph([node]),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph([node]),
                 head = base.remove(node).revert('n'),
                 diff = iD.Difference(base, head);
             expect(diff.changes()).to.eql({});
@@ -95,25 +95,25 @@ describe('iD.Difference', function () {
 
     describe('#extantIDs', function () {
         it('includes the ids of created entities', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph(),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph(),
                 head = base.replace(node),
                 diff = iD.Difference(base, head);
             expect(diff.extantIDs()).to.eql(['n']);
         });
 
         it('includes the ids of modified entities', function () {
-            var n1 = iD.Node({id: 'n'}),
+            var n1 = iD.osmNode({id: 'n'}),
                 n2 = n1.move([1, 2]),
-                base = iD.Graph([n1]),
+                base = iD.coreGraph([n1]),
                 head = base.replace(n2),
                 diff = iD.Difference(base, head);
             expect(diff.extantIDs()).to.eql(['n']);
         });
 
         it('omits the ids of deleted entities', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph([node]),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph([node]),
                 head = base.remove(node),
                 diff = iD.Difference(base, head);
             expect(diff.extantIDs()).to.eql([]);
@@ -122,8 +122,8 @@ describe('iD.Difference', function () {
 
     describe('#created', function () {
         it('returns an array of created entities', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph(),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph(),
                 head = base.replace(node),
                 diff = iD.Difference(base, head);
             expect(diff.created()).to.eql([node]);
@@ -132,9 +132,9 @@ describe('iD.Difference', function () {
 
     describe('#modified', function () {
         it('returns an array of modified entities', function () {
-            var n1 = iD.Node({id: 'n'}),
+            var n1 = iD.osmNode({id: 'n'}),
                 n2 = n1.move([1, 2]),
-                base = iD.Graph([n1]),
+                base = iD.coreGraph([n1]),
                 head = base.replace(n2),
                 diff = iD.Difference(base, head);
             expect(diff.modified()).to.eql([n2]);
@@ -143,8 +143,8 @@ describe('iD.Difference', function () {
 
     describe('#deleted', function () {
         it('returns an array of deleted entities', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph([node]),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph([node]),
                 head = base.remove(node),
                 diff = iD.Difference(base, head);
             expect(diff.deleted()).to.eql([node]);
@@ -152,15 +152,15 @@ describe('iD.Difference', function () {
     });
 
     describe('#summary', function () {
-        var base = iD.Graph([
-            iD.Node({id: 'a', tags: {crossing: 'marked'}}),
-            iD.Node({id: 'b'}),
-            iD.Node({id: 'v'}),
-            iD.Way({id: '-', nodes: ['a', 'b']})
+        var base = iD.coreGraph([
+            iD.osmNode({id: 'a', tags: {crossing: 'marked'}}),
+            iD.osmNode({id: 'b'}),
+            iD.osmNode({id: 'v'}),
+            iD.osmWay({id: '-', nodes: ['a', 'b']})
         ]);
 
         it('reports a created way as created', function() {
-            var way = iD.Way({id: '+'}),
+            var way = iD.osmWay({id: '+'}),
                 head = base.replace(way),
                 diff = iD.Difference(base, head);
 
@@ -208,7 +208,7 @@ describe('iD.Difference', function () {
         });
 
         it('reports a way as modified when a member vertex is added', function() {
-            var vertex = iD.Node({id: 'c'}),
+            var vertex = iD.osmNode({id: 'c'}),
                 way = base.entity('-').addNode('c'),
                 head = base.replace(vertex).replace(way),
                 diff = iD.Difference(base, head);
@@ -234,7 +234,7 @@ describe('iD.Difference', function () {
 
         it('reports a created way containing a moved vertex as being created', function() {
             var vertex = base.entity('b').move([0,3]),
-                way = iD.Way({id: '+', nodes: ['b']}),
+                way = iD.osmWay({id: '+', nodes: ['b']}),
                 head = base.replace(way).replace(vertex),
                 diff = iD.Difference(base, head);
 
@@ -250,8 +250,8 @@ describe('iD.Difference', function () {
         });
 
         it('reports a created way with a created vertex as being created', function() {
-            var vertex = iD.Node({id: 'c'}),
-                way = iD.Way({id: '+', nodes: ['c']}),
+            var vertex = iD.osmNode({id: 'c'}),
+                way = iD.osmWay({id: '+', nodes: ['c']}),
                 head = base.replace(vertex).replace(way),
                 diff = iD.Difference(base, head);
 
@@ -315,7 +315,7 @@ describe('iD.Difference', function () {
         });
 
         it('reports a vertex as created when it has tags', function() {
-            var vertex = iD.Node({id: 'c', tags: {crossing: 'marked'}}),
+            var vertex = iD.osmNode({id: 'c', tags: {crossing: 'marked'}}),
                 way = base.entity('-').addNode('c'),
                 head = base.replace(way).replace(vertex),
                 diff = iD.Difference(base, head);
@@ -334,36 +334,36 @@ describe('iD.Difference', function () {
 
     describe('#complete', function () {
         it('includes created entities', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph(),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph(),
                 head = base.replace(node),
                 diff = iD.Difference(base, head);
             expect(diff.complete().n).to.equal(node);
         });
 
         it('includes modified entities', function () {
-            var n1 = iD.Node({id: 'n'}),
+            var n1 = iD.osmNode({id: 'n'}),
                 n2 = n1.move([1, 2]),
-                base = iD.Graph([n1]),
+                base = iD.coreGraph([n1]),
                 head = base.replace(n2),
                 diff = iD.Difference(base, head);
             expect(diff.complete().n).to.equal(n2);
         });
 
         it('includes deleted entities', function () {
-            var node = iD.Node({id: 'n'}),
-                base = iD.Graph([node]),
+            var node = iD.osmNode({id: 'n'}),
+                base = iD.coreGraph([node]),
                 head = base.remove(node),
                 diff = iD.Difference(base, head);
             expect(diff.complete()).to.eql({n: undefined});
         });
 
         it('includes nodes added to a way', function () {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n2'}),
-                w1 = iD.Way({id: 'w', nodes: ['n1']}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n2'}),
+                w1 = iD.osmWay({id: 'w', nodes: ['n1']}),
                 w2 = w1.addNode('n2'),
-                base = iD.Graph([n1, n2, w1]),
+                base = iD.coreGraph([n1, n2, w1]),
                 head = base.replace(w2),
                 diff = iD.Difference(base, head);
 
@@ -371,11 +371,11 @@ describe('iD.Difference', function () {
         });
 
         it('includes nodes removed from a way', function () {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n2'}),
-                w1 = iD.Way({id: 'w', nodes: ['n1', 'n2']}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n2'}),
+                w1 = iD.osmWay({id: 'w', nodes: ['n1', 'n2']}),
                 w2 = w1.removeNode('n2'),
-                base = iD.Graph([n1, n2, w1]),
+                base = iD.coreGraph([n1, n2, w1]),
                 head = base.replace(w2),
                 diff = iD.Difference(base, head);
 
@@ -383,10 +383,10 @@ describe('iD.Difference', function () {
         });
 
         it('includes parent ways of modified nodes', function () {
-            var n1   = iD.Node({id: 'n'}),
+            var n1   = iD.osmNode({id: 'n'}),
                 n2   = n1.move([1, 2]),
-                way  = iD.Way({id: 'w', nodes: ['n']}),
-                base = iD.Graph([n1, way]),
+                way  = iD.osmWay({id: 'w', nodes: ['n']}),
+                base = iD.coreGraph([n1, way]),
                 head = base.replace(n2),
                 diff = iD.Difference(base, head);
 
@@ -394,10 +394,10 @@ describe('iD.Difference', function () {
         });
 
         it('includes parent relations of modified entities', function () {
-            var n1   = iD.Node({id: 'n'}),
+            var n1   = iD.osmNode({id: 'n'}),
                 n2   = n1.move([1, 2]),
-                rel  = iD.Relation({id: 'r', members: [{id: 'n'}]}),
-                base = iD.Graph([n1, rel]),
+                rel  = iD.osmRelation({id: 'r', members: [{id: 'n'}]}),
+                base = iD.coreGraph([n1, rel]),
                 head = base.replace(n2),
                 diff = iD.Difference(base, head);
 
@@ -405,11 +405,11 @@ describe('iD.Difference', function () {
         });
 
         it('includes parent relations of modified entities, recursively', function () {
-            var n1   = iD.Node({id: 'n'}),
+            var n1   = iD.osmNode({id: 'n'}),
                 n2   = n1.move([1, 2]),
-                rel1 = iD.Relation({id: 'r1', members: [{id: 'n'}]}),
-                rel2 = iD.Relation({id: 'r2', members: [{id: 'r1'}]}),
-                base = iD.Graph([n1, rel1, rel2]),
+                rel1 = iD.osmRelation({id: 'r1', members: [{id: 'n'}]}),
+                rel2 = iD.osmRelation({id: 'r2', members: [{id: 'r1'}]}),
+                base = iD.coreGraph([n1, rel1, rel2]),
                 head = base.replace(n2),
                 diff = iD.Difference(base, head);
 
@@ -417,11 +417,11 @@ describe('iD.Difference', function () {
         });
 
         it('includes parent relations of parent ways of modified nodes', function () {
-            var n1   = iD.Node({id: 'n'}),
+            var n1   = iD.osmNode({id: 'n'}),
                 n2   = n1.move([1, 2]),
-                way  = iD.Way({id: 'w', nodes: ['n']}),
-                rel  = iD.Relation({id: 'r', members: [{id: 'w'}]}),
-                base = iD.Graph([n1, way, rel]),
+                way  = iD.osmWay({id: 'w', nodes: ['n']}),
+                rel  = iD.osmRelation({id: 'r', members: [{id: 'w'}]}),
+                base = iD.coreGraph([n1, way, rel]),
                 head = base.replace(n2),
                 diff = iD.Difference(base, head);
 
@@ -429,10 +429,10 @@ describe('iD.Difference', function () {
         });
 
         it('copes with recursive relations', function () {
-            var node = iD.Node({id: 'n'}),
-                rel1 = iD.Relation({id: 'r1', members: [{id: 'n'}, {id: 'r2'}]}),
-                rel2 = iD.Relation({id: 'r2', members: [{id: 'r1'}]}),
-                base = iD.Graph([node, rel1, rel2]),
+            var node = iD.osmNode({id: 'n'}),
+                rel1 = iD.osmRelation({id: 'r1', members: [{id: 'n'}, {id: 'r2'}]}),
+                rel2 = iD.osmRelation({id: 'r2', members: [{id: 'r1'}]}),
+                base = iD.coreGraph([node, rel1, rel2]),
                 head = base.replace(node.move([1, 2])),
                 diff = iD.Difference(base, head);
 
diff --git a/test/spec/core/graph.js b/test/spec/core/graph.js
index c1badeecc..1912ef371 100644
--- a/test/spec/core/graph.js
+++ b/test/spec/core/graph.js
@@ -1,67 +1,67 @@
-describe('iD.Graph', function() {
+describe('iD.coreGraph', function() {
     describe('constructor', function () {
         it('accepts an entities Array', function () {
             var entity = iD.Entity(),
-                graph = iD.Graph([entity]);
+                graph = iD.coreGraph([entity]);
             expect(graph.entity(entity.id)).to.equal(entity);
         });
 
         it('accepts a Graph', function () {
             var entity = iD.Entity(),
-                graph = iD.Graph(iD.Graph([entity]));
+                graph = iD.coreGraph(iD.coreGraph([entity]));
             expect(graph.entity(entity.id)).to.equal(entity);
         });
 
         it('copies other\'s entities', function () {
             var entity = iD.Entity(),
-                base   = iD.Graph([entity]),
-                graph  = iD.Graph(base);
+                base   = iD.coreGraph([entity]),
+                graph  = iD.coreGraph(base);
             expect(graph.entities).not.to.equal(base.entities);
         });
 
         it('rebases on other\'s base', function () {
-            var base   = iD.Graph(),
-                graph  = iD.Graph(base);
+            var base   = iD.coreGraph(),
+                graph  = iD.coreGraph(base);
             expect(graph.base().entities).to.equal(base.base().entities);
         });
 
         it('freezes by default', function () {
-            expect(iD.Graph().frozen).to.be.true;
+            expect(iD.coreGraph().frozen).to.be.true;
         });
 
         it('remains mutable if passed true as second argument', function () {
-            expect(iD.Graph([], true).frozen).to.be.false;
+            expect(iD.coreGraph([], true).frozen).to.be.false;
         });
     });
 
     describe('#hasEntity', function () {
         it('returns the entity when present', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node]);
             expect(graph.hasEntity(node.id)).to.equal(node);
         });
 
         it('returns undefined when the entity is not present', function () {
-            expect(iD.Graph().hasEntity('1')).to.be.undefined;
+            expect(iD.coreGraph().hasEntity('1')).to.be.undefined;
         });
     });
 
     describe('#entity', function () {
         it('returns the entity when present', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node]);
             expect(graph.entity(node.id)).to.equal(node);
         });
 
         it('throws when the entity is not present', function () {
-            expect(function() { iD.Graph().entity('1'); }).to.throw;
+            expect(function() { iD.coreGraph().entity('1'); }).to.throw;
         });
     });
 
     describe('#rebase', function () {
         it('preserves existing entities', function () {
-            var node = iD.Node({id: 'n'}),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode({id: 'n'}),
+                graph = iD.coreGraph([node]);
 
             graph.rebase([], [graph]);
 
@@ -69,8 +69,8 @@ describe('iD.Graph', function() {
         });
 
         it('includes new entities', function () {
-            var node = iD.Node({id: 'n'}),
-                graph = iD.Graph();
+            var node = iD.osmNode({id: 'n'}),
+                graph = iD.coreGraph();
 
             graph.rebase([node], [graph]);
 
@@ -78,8 +78,8 @@ describe('iD.Graph', function() {
         });
 
         it('doesn\'t rebase deleted entities', function () {
-            var node = iD.Node({id: 'n', visible: false}),
-                graph = iD.Graph();
+            var node = iD.osmNode({id: 'n', visible: false}),
+                graph = iD.coreGraph();
 
             graph.rebase([node], [graph]);
 
@@ -87,9 +87,9 @@ describe('iD.Graph', function() {
         });
 
         it('gives precedence to existing entities', function () {
-            var a = iD.Node({id: 'n'}),
-                b = iD.Node({id: 'n'}),
-                graph = iD.Graph([a]);
+            var a = iD.osmNode({id: 'n'}),
+                b = iD.osmNode({id: 'n'}),
+                graph = iD.coreGraph([a]);
 
             graph.rebase([b], [graph]);
 
@@ -97,9 +97,9 @@ describe('iD.Graph', function() {
         });
 
         it('gives precedence to new entities when force = true', function () {
-            var a = iD.Node({id: 'n'}),
-                b = iD.Node({id: 'n'}),
-                graph = iD.Graph([a]);
+            var a = iD.osmNode({id: 'n'}),
+                b = iD.osmNode({id: 'n'}),
+                graph = iD.coreGraph([a]);
 
             graph.rebase([b], [graph], true);
 
@@ -107,18 +107,18 @@ describe('iD.Graph', function() {
         });
 
         it('inherits entities from base prototypally', function () {
-            var graph = iD.Graph();
+            var graph = iD.coreGraph();
 
-            graph.rebase([iD.Node({id: 'n'})], [graph]);
+            graph.rebase([iD.osmNode({id: 'n'})], [graph]);
 
             expect(graph.entities).not.to.have.ownProperty('n');
         });
 
         it('updates parentWays', function () {
-            var n = iD.Node({id: 'n'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n']}),
-                w2 = iD.Way({id: 'w2', nodes: ['n']}),
-                graph = iD.Graph([n, w1]);
+            var n = iD.osmNode({id: 'n'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n']}),
+                w2 = iD.osmWay({id: 'w2', nodes: ['n']}),
+                graph = iD.coreGraph([n, w1]);
 
             graph.rebase([w2], [graph]);
 
@@ -127,9 +127,9 @@ describe('iD.Graph', function() {
         });
 
         it('avoids adding duplicate parentWays', function () {
-            var n = iD.Node({id: 'n'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n']}),
-                graph = iD.Graph([n, w1]);
+            var n = iD.osmNode({id: 'n'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n']}),
+                graph = iD.coreGraph([n, w1]);
 
             graph.rebase([w1], [graph]);
 
@@ -137,11 +137,11 @@ describe('iD.Graph', function() {
         });
 
         it('updates parentWays for nodes with modified parentWays', function () {
-            var n = iD.Node({id: 'n'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n']}),
-                w2 = iD.Way({id: 'w2', nodes: ['n']}),
-                w3 = iD.Way({id: 'w3', nodes: ['n']}),
-                graph = iD.Graph([n, w1]),
+            var n = iD.osmNode({id: 'n'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n']}),
+                w2 = iD.osmWay({id: 'w2', nodes: ['n']}),
+                w3 = iD.osmWay({id: 'w3', nodes: ['n']}),
+                graph = iD.coreGraph([n, w1]),
                 graph2 = graph.replace(w2);
 
             graph.rebase([w3], [graph, graph2]);
@@ -150,11 +150,11 @@ describe('iD.Graph', function() {
         });
 
         it('avoids re-adding a modified way as a parent way', function() {
-            var n1 = iD.Node({id: 'n1'}),
-                n2 = iD.Node({id: 'n2'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n1', 'n2']}),
+            var n1 = iD.osmNode({id: 'n1'}),
+                n2 = iD.osmNode({id: 'n2'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n1', 'n2']}),
                 w2 = w1.removeNode('n2'),
-                graph = iD.Graph([n1, n2, w1]),
+                graph = iD.coreGraph([n1, n2, w1]),
                 graph2 = graph.replace(w2);
 
             graph.rebase([w1], [graph, graph2]);
@@ -163,9 +163,9 @@ describe('iD.Graph', function() {
         });
 
         it('avoids re-adding a deleted way as a parent way', function() {
-            var n = iD.Node({id: 'n'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n']}),
-                graph = iD.Graph([n, w1]),
+            var n = iD.osmNode({id: 'n'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n']}),
+                graph = iD.coreGraph([n, w1]),
                 graph2 = graph.remove(w1);
 
             graph.rebase([w1], [graph, graph2]);
@@ -174,10 +174,10 @@ describe('iD.Graph', function() {
         });
 
         it('re-adds a deleted node that is discovered to have another parent', function() {
-            var n = iD.Node({id: 'n'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n']}),
-                w2 = iD.Way({id: 'w2', nodes: ['n']}),
-                graph = iD.Graph([n, w1]),
+            var n = iD.osmNode({id: 'n'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n']}),
+                w2 = iD.osmWay({id: 'w2', nodes: ['n']}),
+                graph = iD.coreGraph([n, w1]),
                 graph2 = graph.remove(n);
 
             graph.rebase([n, w2], [graph, graph2]);
@@ -186,10 +186,10 @@ describe('iD.Graph', function() {
         });
 
         it('updates parentRelations', function () {
-            var n = iD.Node({id: 'n'}),
-                r1 = iD.Relation({id: 'r1', members: [{id: 'n'}]}),
-                r2 = iD.Relation({id: 'r2', members: [{id: 'n'}]}),
-                graph = iD.Graph([n, r1]);
+            var n = iD.osmNode({id: 'n'}),
+                r1 = iD.osmRelation({id: 'r1', members: [{id: 'n'}]}),
+                r2 = iD.osmRelation({id: 'r2', members: [{id: 'n'}]}),
+                graph = iD.coreGraph([n, r1]);
 
             graph.rebase([r2], [graph]);
 
@@ -198,10 +198,10 @@ describe('iD.Graph', function() {
         });
 
         it('avoids re-adding a modified relation as a parent relation', function() {
-            var n = iD.Node({id: 'n'}),
-                r1 = iD.Relation({id: 'r1', members: [{id: 'n'}]}),
+            var n = iD.osmNode({id: 'n'}),
+                r1 = iD.osmRelation({id: 'r1', members: [{id: 'n'}]}),
                 r2 = r1.removeMembersWithID('n'),
-                graph = iD.Graph([n, r1]),
+                graph = iD.coreGraph([n, r1]),
                 graph2 = graph.replace(r2);
 
             graph.rebase([r1], [graph, graph2]);
@@ -210,9 +210,9 @@ describe('iD.Graph', function() {
         });
 
         it('avoids re-adding a deleted relation as a parent relation', function() {
-            var n = iD.Node({id: 'n'}),
-                r1 = iD.Relation({id: 'r1', members: [{id: 'n'}]}),
-                graph = iD.Graph([n, r1]),
+            var n = iD.osmNode({id: 'n'}),
+                r1 = iD.osmRelation({id: 'r1', members: [{id: 'n'}]}),
+                graph = iD.coreGraph([n, r1]),
                 graph2 = graph.remove(r1);
 
             graph.rebase([r1], [graph, graph2]);
@@ -221,11 +221,11 @@ describe('iD.Graph', function() {
         });
 
         it('updates parentRels for nodes with modified parentWays', function () {
-            var n = iD.Node({id: 'n'}),
-                r1 = iD.Relation({id: 'r1', members: [{id: 'n'}]}),
-                r2 = iD.Relation({id: 'r2', members: [{id: 'n'}]}),
-                r3 = iD.Relation({id: 'r3', members: [{id: 'n'}]}),
-                graph = iD.Graph([n, r1]),
+            var n = iD.osmNode({id: 'n'}),
+                r1 = iD.osmRelation({id: 'r1', members: [{id: 'n'}]}),
+                r2 = iD.osmRelation({id: 'r2', members: [{id: 'n'}]}),
+                r3 = iD.osmRelation({id: 'r3', members: [{id: 'n'}]}),
+                graph = iD.coreGraph([n, r1]),
                 graph2 = graph.replace(r2);
 
             graph.rebase([r3], [graph, graph2]);
@@ -234,10 +234,10 @@ describe('iD.Graph', function() {
         });
 
         it('invalidates transients', function() {
-            var n = iD.Node({id: 'n'}),
-                w1 = iD.Way({id: 'w1', nodes: ['n']}),
-                w2 = iD.Way({id: 'w2', nodes: ['n']}),
-                graph = iD.Graph([n, w1]);
+            var n = iD.osmNode({id: 'n'}),
+                w1 = iD.osmWay({id: 'w1', nodes: ['n']}),
+                w2 = iD.osmWay({id: 'w2', nodes: ['n']}),
+                graph = iD.coreGraph([n, w1]);
 
             function numParents(entity) {
                 return graph.transient(entity, 'numParents', function() {
@@ -253,160 +253,160 @@ describe('iD.Graph', function() {
 
     describe('#remove', function () {
         it('returns a new graph', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node]);
             expect(graph.remove(node)).not.to.equal(graph);
         });
 
         it('doesn\'t modify the receiver', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node]);
             graph.remove(node);
             expect(graph.entity(node.id)).to.equal(node);
         });
 
         it('removes the entity from the result', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node]);
             expect(graph.remove(node).hasEntity(node.id)).to.be.undefined;
         });
 
         it('removes the entity as a parentWay', function () {
-            var node = iD.Node({id: 'n' }),
-                w1 = iD.Way({id: 'w', nodes: ['n']}),
-                graph = iD.Graph([node, w1]);
+            var node = iD.osmNode({id: 'n' }),
+                w1 = iD.osmWay({id: 'w', nodes: ['n']}),
+                graph = iD.coreGraph([node, w1]);
             expect(graph.remove(w1).parentWays(node)).to.eql([]);
         });
 
         it('removes the entity as a parentRelation', function () {
-            var node = iD.Node({id: 'n' }),
-                r1 = iD.Relation({id: 'w', members: [{id: 'n' }]}),
-                graph = iD.Graph([node, r1]);
+            var node = iD.osmNode({id: 'n' }),
+                r1 = iD.osmRelation({id: 'w', members: [{id: 'n' }]}),
+                graph = iD.coreGraph([node, r1]);
             expect(graph.remove(r1).parentRelations(node)).to.eql([]);
         });
     });
 
     describe('#replace', function () {
         it('is a no-op if the replacement is identical to the existing entity', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node]);
             expect(graph.replace(node)).to.equal(graph);
         });
 
         it('returns a new graph', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node]);
             expect(graph.replace(node.update())).not.to.equal(graph);
         });
 
         it('doesn\'t modify the receiver', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node]);
             graph.replace(node);
             expect(graph.entity(node.id)).to.equal(node);
         });
 
         it('replaces the entity in the result', function () {
-            var node1 = iD.Node(),
+            var node1 = iD.osmNode(),
                 node2 = node1.update({}),
-                graph = iD.Graph([node1]);
+                graph = iD.coreGraph([node1]);
             expect(graph.replace(node2).entity(node2.id)).to.equal(node2);
         });
 
         it('adds parentWays',  function () {
-            var node = iD.Node({id: 'n' }),
-                w1 = iD.Way({id: 'w', nodes: ['n']}),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode({id: 'n' }),
+                w1 = iD.osmWay({id: 'w', nodes: ['n']}),
+                graph = iD.coreGraph([node]);
             expect(graph.replace(w1).parentWays(node)).to.eql([w1]);
         });
 
         it('removes parentWays',  function () {
-            var node = iD.Node({id: 'n' }),
-                w1 = iD.Way({id: 'w', nodes: ['n']}),
-                graph = iD.Graph([node, w1]);
+            var node = iD.osmNode({id: 'n' }),
+                w1 = iD.osmWay({id: 'w', nodes: ['n']}),
+                graph = iD.coreGraph([node, w1]);
             expect(graph.remove(w1).parentWays(node)).to.eql([]);
         });
 
         it('doesn\'t add duplicate parentWays',  function () {
-            var node = iD.Node({id: 'n' }),
-                w1 = iD.Way({id: 'w', nodes: ['n']}),
-                graph = iD.Graph([node, w1]);
+            var node = iD.osmNode({id: 'n' }),
+                w1 = iD.osmWay({id: 'w', nodes: ['n']}),
+                graph = iD.coreGraph([node, w1]);
             expect(graph.replace(w1).parentWays(node)).to.eql([w1]);
         });
 
         it('adds parentRelations',  function () {
-            var node = iD.Node({id: 'n' }),
-                r1 = iD.Relation({id: 'r', members: [{id: 'n'}]}),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode({id: 'n' }),
+                r1 = iD.osmRelation({id: 'r', members: [{id: 'n'}]}),
+                graph = iD.coreGraph([node]);
             expect(graph.replace(r1).parentRelations(node)).to.eql([r1]);
         });
 
         it('removes parentRelations',  function () {
-            var node = iD.Node({id: 'n' }),
-                r1 = iD.Relation({id: 'r', members: [{id: 'n'}]}),
-                graph = iD.Graph([node, r1]);
+            var node = iD.osmNode({id: 'n' }),
+                r1 = iD.osmRelation({id: 'r', members: [{id: 'n'}]}),
+                graph = iD.coreGraph([node, r1]);
             expect(graph.remove(r1).parentRelations(node)).to.eql([]);
         });
 
         it('doesn\'t add duplicate parentRelations',  function () {
-            var node = iD.Node({id: 'n' }),
-                r1 = iD.Relation({id: 'r', members: [{id: 'n'}]}),
-                graph = iD.Graph([node, r1]);
+            var node = iD.osmNode({id: 'n' }),
+                r1 = iD.osmRelation({id: 'r', members: [{id: 'n'}]}),
+                graph = iD.coreGraph([node, r1]);
             expect(graph.replace(r1).parentRelations(node)).to.eql([r1]);
         });
     });
 
     describe('#revert', function () {
         it('is a no-op if the head entity is identical to the base entity', function () {
-            var n1 = iD.Node({id: 'n'}),
-                graph = iD.Graph([n1]);
+            var n1 = iD.osmNode({id: 'n'}),
+                graph = iD.coreGraph([n1]);
             expect(graph.revert('n')).to.equal(graph);
         });
 
         it('returns a new graph', function () {
-            var n1 = iD.Node({id: 'n'}),
+            var n1 = iD.osmNode({id: 'n'}),
                 n2 = n1.update({}),
-                graph = iD.Graph([n1]).replace(n2);
+                graph = iD.coreGraph([n1]).replace(n2);
             expect(graph.revert('n')).not.to.equal(graph);
         });
 
         it('doesn\'t modify the receiver', function () {
-            var n1 = iD.Node({id: 'n'}),
+            var n1 = iD.osmNode({id: 'n'}),
                 n2 = n1.update({}),
-                graph = iD.Graph([n1]).replace(n2);
+                graph = iD.coreGraph([n1]).replace(n2);
             graph.revert('n');
             expect(graph.hasEntity('n')).to.equal(n2);
         });
 
         it('removes a new entity', function () {
-            var n1 = iD.Node({id: 'n'}),
-                graph = iD.Graph().replace(n1);
+            var n1 = iD.osmNode({id: 'n'}),
+                graph = iD.coreGraph().replace(n1);
 
             graph = graph.revert('n');
             expect(graph.hasEntity('n')).to.be.undefined;
         });
 
         it('reverts an updated entity to the base version', function () {
-            var n1 = iD.Node({id: 'n'}),
+            var n1 = iD.osmNode({id: 'n'}),
                 n2 = n1.update({}),
-                graph = iD.Graph([n1]).replace(n2);
+                graph = iD.coreGraph([n1]).replace(n2);
 
             graph = graph.revert('n');
             expect(graph.hasEntity('n')).to.equal(n1);
         });
 
         it('restores a deleted entity', function () {
-            var n1 = iD.Node({id: 'n'}),
-                graph = iD.Graph([n1]).remove(n1);
+            var n1 = iD.osmNode({id: 'n'}),
+                graph = iD.coreGraph([n1]).remove(n1);
 
             graph = graph.revert('n');
             expect(graph.hasEntity('n')).to.equal(n1);
         });
 
         it('removes new parentWays', function () {
-            var n1 = iD.Node({id: 'n'}),
-                w1 = iD.Way({id: 'w', nodes: ['n']}),
-                graph = iD.Graph().replace(n1).replace(w1);
+            var n1 = iD.osmNode({id: 'n'}),
+                w1 = iD.osmWay({id: 'w', nodes: ['n']}),
+                graph = iD.coreGraph().replace(n1).replace(w1);
 
             graph = graph.revert('w');
             expect(graph.hasEntity('n')).to.equal(n1);
@@ -414,9 +414,9 @@ describe('iD.Graph', function() {
         });
 
         it('removes new parentRelations', function () {
-            var n1 = iD.Node({id: 'n'}),
-                r1 = iD.Relation({id: 'r', members: [{id: 'n'}]}),
-                graph = iD.Graph().replace(n1).replace(r1);
+            var n1 = iD.osmNode({id: 'n'}),
+                r1 = iD.osmRelation({id: 'r', members: [{id: 'n'}]}),
+                graph = iD.coreGraph().replace(n1).replace(r1);
 
             graph = graph.revert('r');
             expect(graph.hasEntity('n')).to.equal(n1);
@@ -424,10 +424,10 @@ describe('iD.Graph', function() {
         });
 
         it('reverts updated parentWays', function () {
-            var n1 = iD.Node({id: 'n'}),
-                w1 = iD.Way({id: 'w', nodes: ['n']}),
+            var n1 = iD.osmNode({id: 'n'}),
+                w1 = iD.osmWay({id: 'w', nodes: ['n']}),
                 w2 = w1.removeNode('n'),
-                graph = iD.Graph([n1, w1]).replace(w2);
+                graph = iD.coreGraph([n1, w1]).replace(w2);
 
             graph = graph.revert('w');
             expect(graph.hasEntity('n')).to.equal(n1);
@@ -435,10 +435,10 @@ describe('iD.Graph', function() {
         });
 
         it('reverts updated parentRelations', function () {
-            var n1 = iD.Node({id: 'n'}),
-                r1 = iD.Relation({id: 'r', members: [{id: 'n'}]}),
+            var n1 = iD.osmNode({id: 'n'}),
+                r1 = iD.osmRelation({id: 'r', members: [{id: 'n'}]}),
                 r2 = r1.removeMembersWithID('n'),
-                graph = iD.Graph([n1, r1]).replace(r2);
+                graph = iD.coreGraph([n1, r1]).replace(r2);
 
             graph = graph.revert('r');
             expect(graph.hasEntity('n')).to.equal(n1);
@@ -446,9 +446,9 @@ describe('iD.Graph', function() {
         });
 
         it('restores deleted parentWays', function () {
-            var n1 = iD.Node({id: 'n'}),
-                w1 = iD.Way({id: 'w', nodes: ['n']}),
-                graph = iD.Graph([n1, w1]).remove(w1);
+            var n1 = iD.osmNode({id: 'n'}),
+                w1 = iD.osmWay({id: 'w', nodes: ['n']}),
+                graph = iD.coreGraph([n1, w1]).remove(w1);
 
             graph = graph.revert('w');
             expect(graph.hasEntity('n')).to.equal(n1);
@@ -456,9 +456,9 @@ describe('iD.Graph', function() {
         });
 
         it('restores deleted parentRelations', function () {
-            var n1 = iD.Node({id: 'n'}),
-                r1 = iD.Relation({id: 'r', members: [{id: 'n'}]}),
-                graph = iD.Graph([n1, r1]).remove(r1);
+            var n1 = iD.osmNode({id: 'n'}),
+                r1 = iD.osmRelation({id: 'r', members: [{id: 'n'}]}),
+                graph = iD.coreGraph([n1, r1]).remove(r1);
 
             graph = graph.revert('r');
             expect(graph.hasEntity('n')).to.equal(n1);
@@ -468,18 +468,18 @@ describe('iD.Graph', function() {
 
     describe('#update', function () {
         it('returns a new graph if self is frozen', function () {
-            var graph = iD.Graph();
+            var graph = iD.coreGraph();
             expect(graph.update()).not.to.equal(graph);
         });
 
         it('returns self if self is not frozen', function () {
-            var graph = iD.Graph([], true);
+            var graph = iD.coreGraph([], true);
             expect(graph.update()).to.equal(graph);
         });
 
         it('doesn\'t modify self is self is frozen', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node]);
 
             graph.update(function (graph) { graph.remove(node); });
 
@@ -487,8 +487,8 @@ describe('iD.Graph', function() {
         });
 
         it('modifies self is self is not frozen', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node], true);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node], true);
 
             graph.update(function (graph) { graph.remove(node); });
 
@@ -496,9 +496,9 @@ describe('iD.Graph', function() {
         });
 
         it('executes all of the given functions', function () {
-            var a = iD.Node(),
-                b = iD.Node(),
-                graph = iD.Graph([a]);
+            var a = iD.osmNode(),
+                b = iD.osmNode(),
+                graph = iD.coreGraph([a]);
 
             graph = graph.update(
                 function (graph) { graph.remove(a); },
@@ -512,9 +512,9 @@ describe('iD.Graph', function() {
 
     describe('#parentWays', function() {
         it('returns an array of ways that contain the given node id', function () {
-            var node  = iD.Node({id: 'n1'}),
-                way   = iD.Way({id: 'w1', nodes: ['n1']}),
-                graph = iD.Graph([node, way]);
+            var node  = iD.osmNode({id: 'n1'}),
+                way   = iD.osmWay({id: 'w1', nodes: ['n1']}),
+                graph = iD.coreGraph([node, way]);
             expect(graph.parentWays(node)).to.eql([way]);
             expect(graph.parentWays(way)).to.eql([]);
         });
@@ -522,10 +522,10 @@ describe('iD.Graph', function() {
 
     describe('#parentRelations', function() {
         it('returns an array of relations that contain the given entity id', function () {
-            var node     = iD.Node({id: 'n1'}),
-                nonnode  = iD.Node({id: 'n2'}),
-                relation = iD.Relation({id: 'r1', members: [{ id: 'n1', role: 'from' }]}),
-                graph    = iD.Graph([node, relation]);
+            var node     = iD.osmNode({id: 'n1'}),
+                nonnode  = iD.osmNode({id: 'n2'}),
+                relation = iD.osmRelation({id: 'r1', members: [{ id: 'n1', role: 'from' }]}),
+                graph    = iD.coreGraph([node, relation]);
             expect(graph.parentRelations(node)).to.eql([relation]);
             expect(graph.parentRelations(nonnode)).to.eql([]);
         });
@@ -533,9 +533,9 @@ describe('iD.Graph', function() {
 
     describe('#childNodes', function () {
         it('returns an array of child nodes', function () {
-            var node  = iD.Node({id: 'n1'}),
-                way   = iD.Way({id: 'w1', nodes: ['n1']}),
-                graph = iD.Graph([node, way]);
+            var node  = iD.osmNode({id: 'n1'}),
+                way   = iD.osmWay({id: 'w1', nodes: ['n1']}),
+                graph = iD.coreGraph([node, way]);
             expect(graph.childNodes(way)).to.eql([node]);
         });
     });
diff --git a/test/spec/core/history.js b/test/spec/core/history.js
index 467e48d5f..3c1533d3b 100644
--- a/test/spec/core/history.js
+++ b/test/spec/core/history.js
@@ -1,9 +1,9 @@
 describe('iD.History', function () {
     var context, history, spy,
-        action = function() { return iD.Graph(); };
+        action = function() { return iD.coreGraph(); };
 
     beforeEach(function () {
-        context = iD.Context();
+        context = iD.coreContext();
         history = context.history();
         spy = sinon.spy();
         // clear lock
@@ -12,13 +12,13 @@ describe('iD.History', function () {
 
     describe('#graph', function () {
         it('returns the current graph', function () {
-            expect(history.graph()).to.be.an.instanceOf(iD.Graph);
+            expect(history.graph()).to.be.an.instanceOf(iD.coreGraph);
         });
     });
 
     describe('#merge', function () {
         it('merges the entities into all graph versions', function () {
-            var n = iD.Node({id: 'n'});
+            var n = iD.osmNode({id: 'n'});
             history.merge([n]);
             expect(history.graph().entity('n')).to.equal(n);
         });
@@ -37,7 +37,7 @@ describe('iD.History', function () {
         });
 
         it('updates the graph', function () {
-            var node = iD.Node();
+            var node = iD.osmNode();
             history.perform(function (graph) { return graph.replace(node); });
             expect(history.graph().entity(node.id)).to.equal(node);
         });
@@ -55,8 +55,8 @@ describe('iD.History', function () {
         });
 
         it('performs multiple actions', function () {
-            var action1 = sinon.stub().returns(iD.Graph()),
-                action2 = sinon.stub().returns(iD.Graph());
+            var action1 = sinon.stub().returns(iD.coreGraph()),
+                action2 = sinon.stub().returns(iD.coreGraph());
             history.perform(action1, action2, 'annotation');
             expect(action1).to.have.been.called;
             expect(action2).to.have.been.called;
@@ -64,7 +64,7 @@ describe('iD.History', function () {
         });
 
         it('performs transitionable actions in a transition', function (done) {
-            var action1 = function() { return iD.Graph(); };
+            var action1 = function() { return iD.coreGraph(); };
             action1.transitionable = true;
             history.on('change', spy);
             history.perform(action1);
@@ -81,7 +81,7 @@ describe('iD.History', function () {
         });
 
         it('updates the graph', function () {
-            var node = iD.Node();
+            var node = iD.osmNode();
             history.replace(function (graph) { return graph.replace(node); });
             expect(history.graph().entity(node.id)).to.equal(node);
         });
@@ -99,8 +99,8 @@ describe('iD.History', function () {
         });
 
         it('performs multiple actions', function () {
-            var action1 = sinon.stub().returns(iD.Graph()),
-                action2 = sinon.stub().returns(iD.Graph());
+            var action1 = sinon.stub().returns(iD.coreGraph()),
+                action2 = sinon.stub().returns(iD.coreGraph());
             history.replace(action1, action2, 'annotation');
             expect(action1).to.have.been.called;
             expect(action2).to.have.been.called;
@@ -168,7 +168,7 @@ describe('iD.History', function () {
 
         it('updates the graph', function () {
             history.perform(action, 'annotation');
-            var node = iD.Node();
+            var node = iD.osmNode();
             history.overwrite(function (graph) { return graph.replace(node); });
             expect(history.graph().entity(node.id)).to.equal(node);
         });
@@ -193,8 +193,8 @@ describe('iD.History', function () {
         });
 
         it('performs multiple actions', function () {
-            var action1 = sinon.stub().returns(iD.Graph()),
-                action2 = sinon.stub().returns(iD.Graph());
+            var action1 = sinon.stub().returns(iD.coreGraph()),
+                action2 = sinon.stub().returns(iD.coreGraph());
             history.perform(action, 'annotation');
             history.overwrite(action1, action2, 'annotation2');
             expect(action1).to.have.been.called;
@@ -268,13 +268,13 @@ describe('iD.History', function () {
 
     describe('#changes', function () {
         it('includes created entities', function () {
-            var node = iD.Node();
+            var node = iD.osmNode();
             history.perform(function (graph) { return graph.replace(node); });
             expect(history.changes().created).to.eql([node]);
         });
 
         it('includes modified entities', function () {
-            var node1 = iD.Node({id: 'n1'}),
+            var node1 = iD.osmNode({id: 'n1'}),
                 node2 = node1.update({ tags: { yes: 'no' } });
             history.merge([node1]);
             history.perform(function (graph) { return graph.replace(node2); });
@@ -282,7 +282,7 @@ describe('iD.History', function () {
         });
 
         it('includes deleted entities', function () {
-            var node = iD.Node({id: 'n1'});
+            var node = iD.osmNode({id: 'n1'});
             history.merge([node]);
             history.perform(function (graph) { return graph.remove(node); });
             expect(history.changes().deleted).to.eql([node]);
@@ -291,7 +291,7 @@ describe('iD.History', function () {
 
     describe('#hasChanges', function() {
         it('is true when any of change\'s values are nonempty', function() {
-            var node = iD.Node();
+            var node = iD.osmNode();
             history.perform(function (graph) { return graph.replace(node); });
             expect(history.hasChanges()).to.eql(true);
         });
@@ -350,17 +350,17 @@ describe('iD.History', function () {
 
     describe('#toJSON', function() {
         it('doesn\'t generate unsaveable changes', function() {
-            var node_1 = iD.Node({id: 'n-1'});
+            var node_1 = iD.osmNode({id: 'n-1'});
             history.perform(iD.actionAddEntity(node_1));
             history.perform(iD.actionDeleteNode('n-1'));
             expect(history.toJSON()).to.be.not.ok;
         });
 
         it('generates v3 JSON', function() {
-            var node_1 = iD.Node({id: 'n-1'}),
-                node1 = iD.Node({id: 'n1'}),
-                node2 = iD.Node({id: 'n2'}),
-                node3 = iD.Node({id: 'n3'});
+            var node_1 = iD.osmNode({id: 'n-1'}),
+                node1 = iD.osmNode({id: 'n1'}),
+                node2 = iD.osmNode({id: 'n2'}),
+                node3 = iD.osmNode({id: 'n3'});
             history.merge([node1, node2, node3]);
             history.perform(iD.actionAddEntity(node_1));           // addition
             history.perform(iD.actionChangeTags('n2', {k: 'v'}));  // modification
@@ -397,7 +397,7 @@ describe('iD.History', function () {
                 'index': 1
             };
             history.fromJSON(JSON.stringify(json));
-            expect(history.graph().entity('n-1')).to.eql(iD.Node({id: 'n-1', loc: [1, 2]}));
+            expect(history.graph().entity('n-1')).to.eql(iD.osmNode({id: 'n-1', loc: [1, 2]}));
             expect(history.undoAnnotation()).to.eql('Added a point.');
             expect(history.imageryUsed()).to.eql(['Bing']);
             expect(iD.Entity.id.next).to.eql({node: -2, way: -1, relation: -1});
@@ -414,7 +414,7 @@ describe('iD.History', function () {
                 'index': 2
             };
             history.fromJSON(JSON.stringify(json));
-            expect(history.graph().entity('n-1')).to.eql(iD.Node({id: 'n-1', loc: [2, 3], v: 1}));
+            expect(history.graph().entity('n-1')).to.eql(iD.osmNode({id: 'n-1', loc: [2, 3], v: 1}));
             expect(history.undoAnnotation()).to.eql('Moved a point.');
             expect(history.imageryUsed()).to.eql(['Bing']);
             expect(iD.Entity.id.next).to.eql({node: -2, way: -1, relation: -1});
@@ -430,7 +430,7 @@ describe('iD.History', function () {
                 'index': 1
             };
             history.fromJSON(JSON.stringify(json));
-            history.merge([iD.Node({id: 'n1'})]);
+            history.merge([iD.osmNode({id: 'n1'})]);
             expect(history.graph().hasEntity('n1')).to.be.undefined;
             expect(history.undoAnnotation()).to.eql('Deleted a point.');
             expect(history.imageryUsed()).to.eql(['Bing']);
@@ -451,7 +451,7 @@ describe('iD.History', function () {
                 'index': 1
             };
             history.fromJSON(JSON.stringify(json));
-            expect(history.graph().entity('n-1')).to.eql(iD.Node({id: 'n-1', loc: [1, 2]}));
+            expect(history.graph().entity('n-1')).to.eql(iD.osmNode({id: 'n-1', loc: [1, 2]}));
             expect(history.undoAnnotation()).to.eql('Added a point.');
             expect(history.imageryUsed()).to.eql(['Bing']);
             expect(iD.Entity.id.next).to.eql({node: -2, way: -1, relation: -1});
@@ -472,8 +472,8 @@ describe('iD.History', function () {
                 'index': 1
             };
             history.fromJSON(JSON.stringify(json));
-            history.merge([iD.Node({id: 'n1'})]); // Shouldn't be necessary; flaw in v2 format (see #2135)
-            expect(history.graph().entity('n1')).to.eql(iD.Node({id: 'n1', loc: [2, 3], v: 1}));
+            history.merge([iD.osmNode({id: 'n1'})]); // Shouldn't be necessary; flaw in v2 format (see #2135)
+            expect(history.graph().entity('n1')).to.eql(iD.osmNode({id: 'n1', loc: [2, 3], v: 1}));
             expect(history.undoAnnotation()).to.eql('Moved a point.');
             expect(history.imageryUsed()).to.eql(['Bing']);
             expect(iD.Entity.id.next).to.eql({node: -2, way: -1, relation: -1});
@@ -492,7 +492,7 @@ describe('iD.History', function () {
                 'index': 1
             };
             history.fromJSON(JSON.stringify(json));
-            history.merge([iD.Node({id: 'n1'})]); // Shouldn't be necessary; flaw in v2 format (see #2135)
+            history.merge([iD.osmNode({id: 'n1'})]); // Shouldn't be necessary; flaw in v2 format (see #2135)
             expect(history.graph().hasEntity('n1')).to.be.undefined;
             expect(history.undoAnnotation()).to.eql('Deleted a point.');
             expect(history.imageryUsed()).to.eql(['Bing']);
@@ -515,7 +515,7 @@ describe('iD.History', function () {
                 'index': 1
             };
             history.fromJSON(JSON.stringify(json));
-            expect(history.graph().entity('n-1')).to.eql(iD.Node({id: 'n-1', loc: [1, 2]}));
+            expect(history.graph().entity('n-1')).to.eql(iD.osmNode({id: 'n-1', loc: [1, 2]}));
             expect(history.undoAnnotation()).to.eql('Added a point.');
             expect(history.imageryUsed()).to.eql(['Bing']);
             expect(iD.Entity.id.next).to.eql({node: -2, way: -1, relation: -1});
@@ -537,7 +537,7 @@ describe('iD.History', function () {
                 'index': 1
             };
             history.fromJSON(JSON.stringify(json));
-            expect(history.graph().entity('n1')).to.eql(iD.Node({id: 'n1', loc: [2, 3], v: 1}));
+            expect(history.graph().entity('n1')).to.eql(iD.osmNode({id: 'n1', loc: [2, 3], v: 1}));
             expect(history.undoAnnotation()).to.eql('Moved a point.');
             expect(history.imageryUsed()).to.eql(['Bing']);
             expect(iD.Entity.id.next).to.eql({node: -2, way: -1, relation: -1});
diff --git a/test/spec/core/tree.js b/test/spec/core/tree.js
index 02516fedf..7f0522d8b 100644
--- a/test/spec/core/tree.js
+++ b/test/spec/core/tree.js
@@ -1,9 +1,9 @@
 describe('iD.Tree', function() {
     describe('#rebase', function() {
         it('adds entities to the tree', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                node = iD.Node({id: 'n', loc: [1, 1]});
+                node = iD.osmNode({id: 'n', loc: [1, 1]});
 
             graph.rebase([node], [graph]);
             tree.rebase([node]);
@@ -12,9 +12,9 @@ describe('iD.Tree', function() {
         });
 
         it('is idempotent', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                node = iD.Node({id: 'n', loc: [1, 1]}),
+                node = iD.osmNode({id: 'n', loc: [1, 1]}),
                 extent = iD.geoExtent([0, 0], [2, 2]);
 
             graph.rebase([node], [graph]);
@@ -27,9 +27,9 @@ describe('iD.Tree', function() {
         });
 
         it('does not insert if entity has a modified version', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                node = iD.Node({id: 'n', loc: [1, 1]}),
+                node = iD.osmNode({id: 'n', loc: [1, 1]}),
                 node_ = node.update({loc: [10, 10]}),
                 g = graph.replace(node_);
 
@@ -43,10 +43,10 @@ describe('iD.Tree', function() {
         });
 
         it('does not error on self-referencing relations', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                node = iD.Node({id: 'n', loc: [1, 1]}),
-                relation = iD.Relation();
+                node = iD.osmNode({id: 'n', loc: [1, 1]}),
+                relation = iD.osmRelation();
 
             relation = relation.addMember({id: node.id});
             relation = relation.addMember({id: relation.id});
@@ -58,9 +58,9 @@ describe('iD.Tree', function() {
         });
 
         it('adjusts entities that are force-rebased', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                node = iD.Node({id: 'n', loc: [1, 1]});
+                node = iD.osmNode({id: 'n', loc: [1, 1]});
 
             graph.rebase([node], [graph]);
             tree.rebase([node]);
@@ -75,10 +75,10 @@ describe('iD.Tree', function() {
 
     describe('#intersects', function() {
         it('includes entities within extent, excludes those without', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                n1 = iD.Node({loc: [1, 1]}),
-                n2 = iD.Node({loc: [3, 3]}),
+                n1 = iD.osmNode({loc: [1, 1]}),
+                n2 = iD.osmNode({loc: [3, 3]}),
                 extent = iD.geoExtent([0, 0], [2, 2]);
 
             graph = graph.replace(n1).replace(n2);
@@ -86,11 +86,11 @@ describe('iD.Tree', function() {
         });
 
         it('includes intersecting relations after incomplete members are loaded', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                n1 = iD.Node({id: 'n1', loc: [0, 0]}),
-                n2 = iD.Node({id: 'n2', loc: [1, 1]}),
-                relation = iD.Relation({id: 'r', members: [{id: 'n1'}, {id: 'n2'}]}),
+                n1 = iD.osmNode({id: 'n1', loc: [0, 0]}),
+                n2 = iD.osmNode({id: 'n2', loc: [1, 1]}),
+                relation = iD.osmRelation({id: 'r', members: [{id: 'n1'}, {id: 'n2'}]}),
                 extent = iD.geoExtent([0.5, 0.5], [1.5, 1.5]);
 
             graph.rebase([relation, n1], [graph]);
@@ -104,10 +104,10 @@ describe('iD.Tree', function() {
 
         // This happens when local storage includes a changed way but not its nodes.
         it('includes intersecting ways after missing nodes are loaded', function() {
-            var base = iD.Graph(),
+            var base = iD.coreGraph(),
                 tree = iD.Tree(base),
-                node = iD.Node({id: 'n', loc: [0.5, 0.5]}),
-                way = iD.Way({nodes: ['n']}),
+                node = iD.osmNode({id: 'n', loc: [0.5, 0.5]}),
+                way = iD.osmWay({nodes: ['n']}),
                 graph = base.replace(way),
                 extent = iD.geoExtent([0, 0], [1, 1]);
 
@@ -119,10 +119,10 @@ describe('iD.Tree', function() {
         });
 
         it('adjusts parent ways when a member node is moved', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                node = iD.Node({id: 'n', loc: [1, 1]}),
-                way = iD.Way({nodes: ['n']}),
+                node = iD.osmNode({id: 'n', loc: [1, 1]}),
+                way = iD.osmWay({nodes: ['n']}),
                 extent = iD.geoExtent([0, 0], [2, 2]);
 
             graph = graph.replace(node).replace(way);
@@ -133,10 +133,10 @@ describe('iD.Tree', function() {
         });
 
         it('adjusts parent relations when a member node is moved', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                node = iD.Node({id: 'n', loc: [1, 1]}),
-                relation = iD.Relation({members: [{type: 'node', id: 'n'}]}),
+                node = iD.osmNode({id: 'n', loc: [1, 1]}),
+                relation = iD.osmRelation({members: [{type: 'node', id: 'n'}]}),
                 extent = iD.geoExtent([0, 0], [2, 2]);
 
             graph = graph.replace(node).replace(relation);
@@ -147,11 +147,11 @@ describe('iD.Tree', function() {
         });
 
         it('adjusts parent relations of parent ways when a member node is moved', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                node = iD.Node({id: 'n', loc: [1, 1]}),
-                way = iD.Way({id: 'w', nodes: ['n']}),
-                relation = iD.Relation({members: [{type: 'multipolygon', id: 'w'}]}),
+                node = iD.osmNode({id: 'n', loc: [1, 1]}),
+                way = iD.osmWay({id: 'w', nodes: ['n']}),
+                relation = iD.osmRelation({members: [{type: 'multipolygon', id: 'w'}]}),
                 extent = iD.geoExtent([0, 0], [2, 2]);
 
             graph = graph.replace(node).replace(way).replace(relation);
@@ -162,11 +162,11 @@ describe('iD.Tree', function() {
         });
 
         it('adjusts parent ways when a member node is removed', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                n1 = iD.Node({id: 'n1', loc: [1, 1]}),
-                n2 = iD.Node({id: 'n2', loc: [3, 3]}),
-                way = iD.Way({nodes: ['n1', 'n2']}),
+                n1 = iD.osmNode({id: 'n1', loc: [1, 1]}),
+                n2 = iD.osmNode({id: 'n2', loc: [3, 3]}),
+                way = iD.osmWay({nodes: ['n1', 'n2']}),
                 extent = iD.geoExtent([0, 0], [2, 2]);
 
             graph = graph.replace(n1).replace(n2).replace(way);
@@ -178,11 +178,11 @@ describe('iD.Tree', function() {
 
         it('don\'t include parent way multiple times when multiple child nodes are moved', function() {
             // checks against the following regression: https://github.com/openstreetmap/iD/issues/1978
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                n1 = iD.Node({id: 'n1', loc: [1, 1]}),
-                n2 = iD.Node({id: 'n2', loc: [3, 3]}),
-                way = iD.Way({id: 'w1', nodes: ['n1', 'n2']}),
+                n1 = iD.osmNode({id: 'n1', loc: [1, 1]}),
+                n2 = iD.osmNode({id: 'n2', loc: [3, 3]}),
+                way = iD.osmWay({id: 'w1', nodes: ['n1', 'n2']}),
                 extent = iD.geoExtent([0, 0], [4, 4]);
 
             graph = graph.replace(n1).replace(n2).replace(way);
@@ -194,9 +194,9 @@ describe('iD.Tree', function() {
         });
 
         it('doesn\'t include removed entities', function() {
-            var graph = iD.Graph(),
+            var graph = iD.coreGraph(),
                 tree = iD.Tree(graph),
-                node = iD.Node({loc: [1, 1]}),
+                node = iD.osmNode({loc: [1, 1]}),
                 extent = iD.geoExtent([0, 0], [2, 2]);
 
             graph = graph.replace(node);
@@ -207,9 +207,9 @@ describe('iD.Tree', function() {
         });
 
         it('doesn\'t include removed entities after rebase', function() {
-            var base = iD.Graph(),
+            var base = iD.coreGraph(),
                 tree = iD.Tree(base),
-                node = iD.Node({id: 'n', loc: [1, 1]}),
+                node = iD.osmNode({id: 'n', loc: [1, 1]}),
                 extent = iD.geoExtent([0, 0], [2, 2]);
 
             var graph = base.replace(node).remove(node);
@@ -221,11 +221,11 @@ describe('iD.Tree', function() {
         });
 
         it('handles recursive relations', function() {
-            var base = iD.Graph(),
+            var base = iD.coreGraph(),
                 tree = iD.Tree(base),
-                node = iD.Node({id: 'n', loc: [1, 1]}),
-                r1   = iD.Relation({id: 'r1', members: [{id: 'n'}]}),
-                r2   = iD.Relation({id: 'r2', members: [{id: 'r1'}]}),
+                node = iD.osmNode({id: 'n', loc: [1, 1]}),
+                r1   = iD.osmRelation({id: 'r1', members: [{id: 'n'}]}),
+                r2   = iD.osmRelation({id: 'r2', members: [{id: 'r1'}]}),
                 extent = iD.geoExtent([0, 0], [2, 2]);
 
             var graph = base.replace(r1).replace(r2);
diff --git a/test/spec/modes/add_point.js b/test/spec/modes/add_point.js
index 8954ca63c..d46cdea98 100644
--- a/test/spec/modes/add_point.js
+++ b/test/spec/modes/add_point.js
@@ -4,7 +4,7 @@ describe.skip('iD.modeAddPoint', function() {
     beforeEach(function() {
         var container = d3.select(document.createElement('div'));
 
-        context = iD.Context()
+        context = iD.coreContext()
             .container(container);
 
         context.loadTiles = function () {};
diff --git a/test/spec/osm/entity.js b/test/spec/osm/entity.js
index de4297e7c..ab06f0000 100644
--- a/test/spec/osm/entity.js
+++ b/test/spec/osm/entity.js
@@ -1,11 +1,11 @@
 describe('iD.osmEntity', function () {
     it('returns a subclass of the appropriate type', function () {
-        expect(iD.Entity({type: 'node'})).be.an.instanceOf(iD.Node);
-        expect(iD.Entity({type: 'way'})).be.an.instanceOf(iD.Way);
-        expect(iD.Entity({type: 'relation'})).be.an.instanceOf(iD.Relation);
-        expect(iD.Entity({id: 'n1'})).be.an.instanceOf(iD.Node);
-        expect(iD.Entity({id: 'w1'})).be.an.instanceOf(iD.Way);
-        expect(iD.Entity({id: 'r1'})).be.an.instanceOf(iD.Relation);
+        expect(iD.Entity({type: 'node'})).be.an.instanceOf(iD.osmNode);
+        expect(iD.Entity({type: 'way'})).be.an.instanceOf(iD.osmWay);
+        expect(iD.Entity({type: 'relation'})).be.an.instanceOf(iD.osmRelation);
+        expect(iD.Entity({id: 'n1'})).be.an.instanceOf(iD.osmNode);
+        expect(iD.Entity({id: 'w1'})).be.an.instanceOf(iD.osmWay);
+        expect(iD.Entity({id: 'r1'})).be.an.instanceOf(iD.osmRelation);
     });
 
     if (iD.debug) {
@@ -175,48 +175,48 @@ describe('iD.osmEntity', function () {
 
     describe('#intersects', function () {
         it('returns true for a way with a node within the given extent', function () {
-            var node  = iD.Node({loc: [0, 0]}),
-                way   = iD.Way({nodes: [node.id]}),
-                graph = iD.Graph([node, way]);
+            var node  = iD.osmNode({loc: [0, 0]}),
+                way   = iD.osmWay({nodes: [node.id]}),
+                graph = iD.coreGraph([node, way]);
             expect(way.intersects([[-5, -5], [5, 5]], graph)).to.equal(true);
         });
 
         it('returns false for way with no nodes within the given extent', function () {
-            var node  = iD.Node({loc: [6, 6]}),
-                way   = iD.Way({nodes: [node.id]}),
-                graph = iD.Graph([node, way]);
+            var node  = iD.osmNode({loc: [6, 6]}),
+                way   = iD.osmWay({nodes: [node.id]}),
+                graph = iD.coreGraph([node, way]);
             expect(way.intersects([[-5, -5], [5, 5]], graph)).to.equal(false);
         });
     });
 
     describe('#hasNonGeometryTags', function () {
         it('returns false for an entity without tags', function () {
-            var node = iD.Node();
+            var node = iD.osmNode();
             expect(node.hasNonGeometryTags()).to.equal(false);
         });
 
         it('returns true for an entity with tags', function () {
-            var node = iD.Node({tags: {foo: 'bar'}});
+            var node = iD.osmNode({tags: {foo: 'bar'}});
             expect(node.hasNonGeometryTags()).to.equal(true);
         });
 
         it('returns false for an entity with only an area=yes tag', function () {
-            var node = iD.Node({tags: {area: 'yes'}});
+            var node = iD.osmNode({tags: {area: 'yes'}});
             expect(node.hasNonGeometryTags()).to.equal(false);
         });
     });
 
     describe('#hasParentRelations', function () {
         it('returns true for an entity that is a relation member', function () {
-            var node = iD.Node(),
-                relation = iD.Relation({members: [{id: node.id}]}),
-                graph = iD.Graph([node, relation]);
+            var node = iD.osmNode(),
+                relation = iD.osmRelation({members: [{id: node.id}]}),
+                graph = iD.coreGraph([node, relation]);
             expect(node.hasParentRelations(graph)).to.equal(true);
         });
 
         it('returns false for an entity that is not a relation member', function () {
-            var node = iD.Node(),
-                graph = iD.Graph([node]);
+            var node = iD.osmNode(),
+                graph = iD.coreGraph([node]);
             expect(node.hasParentRelations(graph)).to.equal(false);
         });
     });
diff --git a/test/spec/osm/lanes.js b/test/spec/osm/lanes.js
index 636d3513b..214a25da4 100644
--- a/test/spec/osm/lanes.js
+++ b/test/spec/osm/lanes.js
@@ -5,26 +5,26 @@ describe('iD.Lanes', function() {
         describe('motorway', function() {
 
             it('returns 2 lanes for highway=motorway', function() {
-                expect(iD.Way({tags: { highway: 'motorway' }}).lanes().metadata.count, 'motorway lanes')
+                expect(iD.osmWay({tags: { highway: 'motorway' }}).lanes().metadata.count, 'motorway lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'motorway', oneway: 'yes' }}).lanes().metadata.count, 'motorway lanes')
+                expect(iD.osmWay({tags: { highway: 'motorway', oneway: 'yes' }}).lanes().metadata.count, 'motorway lanes')
                     .to.eql(2);
             });
 
             it('returns 4 lanes for highway=motorway and oneway=no', function() {
-                expect(iD.Way({tags: { highway: 'motorway', oneway: 'no' }}).lanes().metadata.count, 'motorway lanes')
+                expect(iD.osmWay({tags: { highway: 'motorway', oneway: 'no' }}).lanes().metadata.count, 'motorway lanes')
                     .to.eql(4);
             });
 
             it('returns 2 lanes for highway=motorway_link', function() {
-                expect(iD.Way({tags: { highway: 'motorway_link' }}).lanes().metadata.count, 'motorway_link lanes')
+                expect(iD.osmWay({tags: { highway: 'motorway_link' }}).lanes().metadata.count, 'motorway_link lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'motorway_link', oneway: 'no' }}).lanes().metadata.count, 'motorway_link lanes')
+                expect(iD.osmWay({tags: { highway: 'motorway_link', oneway: 'no' }}).lanes().metadata.count, 'motorway_link lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=motorway_link and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'motorway_link', oneway: 'yes' }}).lanes().metadata.count, 'motorway_link lanes')
+                expect(iD.osmWay({tags: { highway: 'motorway_link', oneway: 'yes' }}).lanes().metadata.count, 'motorway_link lanes')
                     .to.eql(1);
             });
         });
@@ -32,26 +32,26 @@ describe('iD.Lanes', function() {
         describe('trunk', function() {
 
             it('returns 4 lanes for highway=trunk', function() {
-                expect(iD.Way({tags: { highway: 'trunk' }}).lanes().metadata.count, 'trunk lanes')
+                expect(iD.osmWay({tags: { highway: 'trunk' }}).lanes().metadata.count, 'trunk lanes')
                     .to.eql(4);
-                expect(iD.Way({tags: { highway: 'trunk', oneway: 'no' }}).lanes().metadata.count, 'trunk lanes')
+                expect(iD.osmWay({tags: { highway: 'trunk', oneway: 'no' }}).lanes().metadata.count, 'trunk lanes')
                     .to.eql(4);
             });
 
             it('returns 2 lanes for highway=trunk and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'trunk', oneway: 'yes' }}).lanes().metadata.count, 'trunk lanes')
+                expect(iD.osmWay({tags: { highway: 'trunk', oneway: 'yes' }}).lanes().metadata.count, 'trunk lanes')
                     .to.eql(2);
             });
 
             it('returns 2 lanes for highway=trunk_link', function() {
-                expect(iD.Way({tags: { highway: 'trunk_link' }}).lanes().metadata.count, 'trunk_link lanes')
+                expect(iD.osmWay({tags: { highway: 'trunk_link' }}).lanes().metadata.count, 'trunk_link lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'trunk_link', oneway: 'no' }}).lanes().metadata.count, 'trunk_link lanes')
+                expect(iD.osmWay({tags: { highway: 'trunk_link', oneway: 'no' }}).lanes().metadata.count, 'trunk_link lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=trunk_link and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'trunk_link', oneway: 'yes' }}).lanes().metadata.count, 'trunk_link lanes')
+                expect(iD.osmWay({tags: { highway: 'trunk_link', oneway: 'yes' }}).lanes().metadata.count, 'trunk_link lanes')
                     .to.eql(1);
             });
         });
@@ -59,26 +59,26 @@ describe('iD.Lanes', function() {
         describe('primary', function() {
 
             it('returns 2 lanes for highway=primary', function() {
-                expect(iD.Way({tags: { highway: 'primary' }}).lanes().metadata.count, 'primary lanes')
+                expect(iD.osmWay({tags: { highway: 'primary' }}).lanes().metadata.count, 'primary lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'primary', oneway: 'no' }}).lanes().metadata.count, 'primary lanes')
+                expect(iD.osmWay({tags: { highway: 'primary', oneway: 'no' }}).lanes().metadata.count, 'primary lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=primary and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'primary', oneway: 'yes' }}).lanes().metadata.count, 'primary lanes')
+                expect(iD.osmWay({tags: { highway: 'primary', oneway: 'yes' }}).lanes().metadata.count, 'primary lanes')
                     .to.eql(1);
             });
 
             it('returns 2 lanes for highway=primary_link', function() {
-                expect(iD.Way({tags: { highway: 'primary_link' }}).lanes().metadata.count, 'primary lanes')
+                expect(iD.osmWay({tags: { highway: 'primary_link' }}).lanes().metadata.count, 'primary lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'primary_link', oneway: 'no' }}).lanes().metadata.count, 'primary lanes')
+                expect(iD.osmWay({tags: { highway: 'primary_link', oneway: 'no' }}).lanes().metadata.count, 'primary lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=primary_link and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'primary_link', oneway: 'yes' }}).lanes().metadata.count, 'primary lanes')
+                expect(iD.osmWay({tags: { highway: 'primary_link', oneway: 'yes' }}).lanes().metadata.count, 'primary lanes')
                     .to.eql(1);
             });
         });
@@ -86,26 +86,26 @@ describe('iD.Lanes', function() {
         describe('seconday', function() {
 
             it('returns 2 lanes for highway=secondary', function() {
-                expect(iD.Way({tags: { highway: 'secondary' }}).lanes().metadata.count, 'secondary lanes')
+                expect(iD.osmWay({tags: { highway: 'secondary' }}).lanes().metadata.count, 'secondary lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'secondary', oneway: 'no' }}).lanes().metadata.count, 'secondary lanes')
+                expect(iD.osmWay({tags: { highway: 'secondary', oneway: 'no' }}).lanes().metadata.count, 'secondary lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=secondary and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'secondary', oneway: 'yes' }}).lanes().metadata.count, 'secondary lanes')
+                expect(iD.osmWay({tags: { highway: 'secondary', oneway: 'yes' }}).lanes().metadata.count, 'secondary lanes')
                     .to.eql(1);
             });
 
             it('returns 2 lane for highway=secondary_link', function() {
-                expect(iD.Way({tags: { highway: 'secondary_link' }}).lanes().metadata.count, 'secondary_link lanes')
+                expect(iD.osmWay({tags: { highway: 'secondary_link' }}).lanes().metadata.count, 'secondary_link lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'secondary_link', oneway: 'no' }}).lanes().metadata.count, 'secondary_link lanes')
+                expect(iD.osmWay({tags: { highway: 'secondary_link', oneway: 'no' }}).lanes().metadata.count, 'secondary_link lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=secondary_link and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'secondary_link', oneway: 'yes' }}).lanes().metadata.count, 'secondary_link lanes')
+                expect(iD.osmWay({tags: { highway: 'secondary_link', oneway: 'yes' }}).lanes().metadata.count, 'secondary_link lanes')
                     .to.eql(1);
             });
         });
@@ -113,26 +113,26 @@ describe('iD.Lanes', function() {
         describe('tertiary', function() {
 
             it('returns 2 lanes for highway=tertiary', function() {
-                expect(iD.Way({tags: { highway: 'tertiary' }}).lanes().metadata.count, 'tertiary lanes')
+                expect(iD.osmWay({tags: { highway: 'tertiary' }}).lanes().metadata.count, 'tertiary lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'tertiary', oneway: 'no' }}).lanes().metadata.count, 'tertiary lanes')
+                expect(iD.osmWay({tags: { highway: 'tertiary', oneway: 'no' }}).lanes().metadata.count, 'tertiary lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=tertiary and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'tertiary', oneway: 'yes' }}).lanes().metadata.count, 'tertiary lanes')
+                expect(iD.osmWay({tags: { highway: 'tertiary', oneway: 'yes' }}).lanes().metadata.count, 'tertiary lanes')
                     .to.eql(1);
             });
 
             it('returns 2 lane for highway=tertiary_link', function() {
-                expect(iD.Way({tags: { highway: 'tertiary_link' }}).lanes().metadata.count, 'tertiary_link lanes')
+                expect(iD.osmWay({tags: { highway: 'tertiary_link' }}).lanes().metadata.count, 'tertiary_link lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'tertiary_link', oneway: 'no' }}).lanes().metadata.count, 'tertiary_link lanes')
+                expect(iD.osmWay({tags: { highway: 'tertiary_link', oneway: 'no' }}).lanes().metadata.count, 'tertiary_link lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=tertiary_link and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'tertiary_link', oneway: 'yes' }}).lanes().metadata.count, 'tertiary_link lanes')
+                expect(iD.osmWay({tags: { highway: 'tertiary_link', oneway: 'yes' }}).lanes().metadata.count, 'tertiary_link lanes')
                     .to.eql(1);
             });
         });
@@ -140,14 +140,14 @@ describe('iD.Lanes', function() {
         describe('residential', function() {
 
             it('returns 2 lanes for highway=residential', function() {
-                expect(iD.Way({tags: { highway: 'residential' }}).lanes().metadata.count, 'residential lanes')
+                expect(iD.osmWay({tags: { highway: 'residential' }}).lanes().metadata.count, 'residential lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'residential', oneway: 'no' }}).lanes().metadata.count, 'residential lanes')
+                expect(iD.osmWay({tags: { highway: 'residential', oneway: 'no' }}).lanes().metadata.count, 'residential lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=residential and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'residential', oneway: 'yes' }}).lanes().metadata.count, 'residential lanes')
+                expect(iD.osmWay({tags: { highway: 'residential', oneway: 'yes' }}).lanes().metadata.count, 'residential lanes')
                     .to.eql(1);
             });
         });
@@ -155,14 +155,14 @@ describe('iD.Lanes', function() {
         describe('service', function() {
 
             it('returns 2 lanes for highway=service', function() {
-                expect(iD.Way({tags: { highway: 'service' }}).lanes().metadata.count, 'service lanes')
+                expect(iD.osmWay({tags: { highway: 'service' }}).lanes().metadata.count, 'service lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'service', oneway: 'no' }}).lanes().metadata.count, 'service lanes')
+                expect(iD.osmWay({tags: { highway: 'service', oneway: 'no' }}).lanes().metadata.count, 'service lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=service and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'service', oneway: 'yes' }}).lanes().metadata.count, 'service lanes')
+                expect(iD.osmWay({tags: { highway: 'service', oneway: 'yes' }}).lanes().metadata.count, 'service lanes')
                     .to.eql(1);
             });
         });
@@ -170,14 +170,14 @@ describe('iD.Lanes', function() {
         describe('track', function() {
 
             it('returns 2 lanes for highway=track', function() {
-                expect(iD.Way({tags: { highway: 'track' }}).lanes().metadata.count, 'track lanes')
+                expect(iD.osmWay({tags: { highway: 'track' }}).lanes().metadata.count, 'track lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'track', oneway: 'no' }}).lanes().metadata.count, 'track lanes')
+                expect(iD.osmWay({tags: { highway: 'track', oneway: 'no' }}).lanes().metadata.count, 'track lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=track and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'track', oneway: 'yes' }}).lanes().metadata.count, 'track lanes')
+                expect(iD.osmWay({tags: { highway: 'track', oneway: 'yes' }}).lanes().metadata.count, 'track lanes')
                     .to.eql(1);
             });
         });
@@ -185,14 +185,14 @@ describe('iD.Lanes', function() {
         describe('path', function() {
 
             it('returns 2 lanes for highway=path', function() {
-                expect(iD.Way({tags: { highway: 'path' }}).lanes().metadata.count, 'path lanes')
+                expect(iD.osmWay({tags: { highway: 'path' }}).lanes().metadata.count, 'path lanes')
                     .to.eql(2);
-                expect(iD.Way({tags: { highway: 'path', oneway: 'no' }}).lanes().metadata.count, 'path lanes')
+                expect(iD.osmWay({tags: { highway: 'path', oneway: 'no' }}).lanes().metadata.count, 'path lanes')
                     .to.eql(2);
             });
 
             it('returns 1 lane for highway=path and oneway=yes', function() {
-                expect(iD.Way({tags: { highway: 'path', oneway: 'yes' }}).lanes().metadata.count, 'path lanes')
+                expect(iD.osmWay({tags: { highway: 'path', oneway: 'yes' }}).lanes().metadata.count, 'path lanes')
                     .to.eql(1);
             });
         });
@@ -200,9 +200,9 @@ describe('iD.Lanes', function() {
 
     describe('oneway tags', function() {
         it('returns correctly oneway when tagged as oneway', function() {
-            expect(iD.Way({tags: { highway: 'residential', oneway: 'yes' }}).lanes().metadata.oneway, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', oneway: 'yes' }}).lanes().metadata.oneway, 'residential lanes')
                 .to.be.true;
-            expect(iD.Way({tags: { highway: 'residential', oneway: 'no' }}).lanes().metadata.oneway, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', oneway: 'no' }}).lanes().metadata.oneway, 'residential lanes')
                 .to.be.false;
         });
     });
@@ -210,7 +210,7 @@ describe('iD.Lanes', function() {
     describe('lane direction', function() {
 
         it('returns correctly the lane:forward and lane:backward count', function() {
-            expect(iD.Way({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, 'lanes:backward': 1 }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, 'lanes:backward': 1 }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 2,
                     oneway: false,
@@ -218,7 +218,7 @@ describe('iD.Lanes', function() {
                     backward: 1,
                     bothways: 0
                 });
-            expect(iD.Way({tags: { highway: 'residential', lanes: 4, 'lanes:forward': 3, 'lanes:backward': 1 }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 4, 'lanes:forward': 3, 'lanes:backward': 1 }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 4,
                     oneway: false,
@@ -229,7 +229,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly the count if erroneous values are supplied', function() {
-            expect(iD.Way({tags: { highway: 'trunk', lanes: 2, 'lanes:forward': 3 }}).lanes().metadata, 'trunk lanes')
+            expect(iD.osmWay({tags: { highway: 'trunk', lanes: 2, 'lanes:forward': 3 }}).lanes().metadata, 'trunk lanes')
                 .to.include({
                     count: 2,
                     oneway: false,
@@ -240,7 +240,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly forward count when oneway=yes', function() {
-            expect(iD.Way({tags: { highway: 'trunk', lanes: 2, oneway: 'yes' }}).lanes().metadata, 'trunk lanes')
+            expect(iD.osmWay({tags: { highway: 'trunk', lanes: 2, oneway: 'yes' }}).lanes().metadata, 'trunk lanes')
                 .to.include({
                     count: 2,
                     oneway: true,
@@ -251,7 +251,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly backward count the when oneway=-1', function() {
-            expect(iD.Way({tags: { highway: 'primary', lanes: 4, oneway: '-1' }}).lanes().metadata, 'primary lanes')
+            expect(iD.osmWay({tags: { highway: 'primary', lanes: 4, oneway: '-1' }}).lanes().metadata, 'primary lanes')
                 .to.include({
                     count: 4,
                     oneway: true,
@@ -262,7 +262,7 @@ describe('iD.Lanes', function() {
         });
 
         it('skips provided lanes:forward value when oneway=yes', function() {
-            expect(iD.Way({tags: { highway: 'trunk', lanes: 2, oneway: 'yes', 'lanes:forward': 1 }}).lanes().metadata, 'trunk lanes')
+            expect(iD.osmWay({tags: { highway: 'trunk', lanes: 2, oneway: 'yes', 'lanes:forward': 1 }}).lanes().metadata, 'trunk lanes')
                 .to.include({
                     count: 2,
                     oneway: true,
@@ -273,7 +273,7 @@ describe('iD.Lanes', function() {
         });
 
         it('skips provided lanes:backward value when oneway=yes', function() {
-            expect(iD.Way({tags: { highway: 'trunk', lanes: 2, oneway: 'yes', 'lanes:backward': 1 }}).lanes().metadata, 'trunk lanes')
+            expect(iD.osmWay({tags: { highway: 'trunk', lanes: 2, oneway: 'yes', 'lanes:backward': 1 }}).lanes().metadata, 'trunk lanes')
                 .to.include({
                     count: 2,
                     oneway: true,
@@ -284,7 +284,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly forward count if only backward is supplied', function() {
-            expect(iD.Way({tags: { highway: 'residential', lanes: 3, 'lanes:backward': 1, }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 3, 'lanes:backward': 1, }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 3,
                     oneway: false,
@@ -292,7 +292,7 @@ describe('iD.Lanes', function() {
                     backward: 1,
                     bothways: 0
                 });
-            expect(iD.Way({tags: { highway: 'residential', lanes: 4, 'lanes:backward': 3, }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 4, 'lanes:backward': 3, }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 4,
                     oneway: false,
@@ -303,7 +303,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly backward count if only forward is supplied', function() {
-            expect(iD.Way({tags: { highway: 'residential', lanes: 3, 'lanes:forward': 1, }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 3, 'lanes:forward': 1, }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 3,
                     oneway: false,
@@ -311,7 +311,7 @@ describe('iD.Lanes', function() {
                     backward: 2,
                     bothways: 0
                 });
-            expect(iD.Way({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 2,
                     oneway: false,
@@ -322,7 +322,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly backward count if forward and both_ways are supplied', function() {
-            expect(iD.Way({tags: { highway: 'residential', lanes: 3, 'lanes:forward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 3, 'lanes:forward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 3,
                     oneway: false,
@@ -330,7 +330,7 @@ describe('iD.Lanes', function() {
                     backward: 1,
                     bothways: 1
                 });
-            expect(iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 5,
                     oneway: false,
@@ -341,7 +341,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly forward count if backward and both_ways are supplied', function() {
-            expect(iD.Way({tags: { highway: 'residential', lanes: 3, 'lanes:backward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 3, 'lanes:backward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 3,
                     oneway: false,
@@ -349,7 +349,7 @@ describe('iD.Lanes', function() {
                     backward: 1,
                     bothways: 1
                 });
-            expect(iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:backward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 5, 'lanes:backward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 5,
                     oneway: false,
@@ -360,7 +360,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly the lane:both_ways count as 1', function() {
-            expect(iD.Way({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, 'lanes:both_ways': 1 }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 2,
                     oneway: false,
@@ -371,7 +371,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly when lane:both_ways>1', function() {
-            expect(iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 2, 'lanes:both_ways': 2, 'lanes:backward': 2 }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 2, 'lanes:both_ways': 2, 'lanes:backward': 2 }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 5,
                     oneway: false,
@@ -382,7 +382,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly when lane:both_ways is 0 or Not a Number', function() {
-            expect(iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 2, 'lanes:both_ways': 0, 'lanes:backward': 3 }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 2, 'lanes:both_ways': 0, 'lanes:backward': 3 }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 5,
                     oneway: false,
@@ -390,7 +390,7 @@ describe('iD.Lanes', function() {
                     backward: 3,
                     bothways: 0
                 });
-            expect(iD.Way({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, 'lanes:both_ways': 'none' }}).lanes().metadata, 'residential lanes')
+            expect(iD.osmWay({tags: { highway: 'residential', lanes: 2, 'lanes:forward': 1, 'lanes:both_ways': 'none' }}).lanes().metadata, 'residential lanes')
                 .to.include({
                     count: 2,
                     oneway: false,
@@ -404,7 +404,7 @@ describe('iD.Lanes', function() {
 
     describe.skip('lanes array', function() {
       it('should have correct number of direction elements', function() {
-        var lanes = iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 2, 'lanes:both_ways': 0, 'lanes:backward': 3 }}).lanes().lanes;
+        var lanes = iD.osmWay({tags: { highway: 'residential', lanes: 5, 'lanes:forward': 2, 'lanes:both_ways': 0, 'lanes:backward': 3 }}).lanes().lanes;
         var forward = lanes.filter(function(l) {
           return l.direction === 'forward';
         });
@@ -420,7 +420,7 @@ describe('iD.Lanes', function() {
 
       });
       it('should have corrent number of direction elements', function() {
-        var lanes = iD.Way({tags: { highway: 'residential', lanes: 5, 'lanes:backward': 1, 'lanes:both_ways': 1 }}).lanes().lanes;
+        var lanes = iD.osmWay({tags: { highway: 'residential', lanes: 5, 'lanes:backward': 1, 'lanes:both_ways': 1 }}).lanes().lanes;
         var forward = lanes.filter(function(l) {
           return l.direction === 'forward';
         });
@@ -438,7 +438,7 @@ describe('iD.Lanes', function() {
 
     describe('turn lanes', function() {
         it('returns correctly when oneway=yes', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'trunk',
                     oneway: 'yes',
@@ -452,7 +452,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly when oneway=yes and lanes=2', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     oneway: 'yes',
@@ -468,7 +468,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly when lanes=5 and both_ways=1', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -489,7 +489,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly when multiple values are present in a lane and oneway=yes', function() {
-            var lanesData = iD.Way({
+            var lanesData = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 5,
@@ -509,7 +509,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns correctly when multiple values are present in a lane and oneway=no', function() {
-            var lanesData = iD.Way({
+            var lanesData = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 5,
@@ -534,7 +534,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns unknown for every invalid value in turn:lanes', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 3,
@@ -549,7 +549,7 @@ describe('iD.Lanes', function() {
         });
 
         it('returns unknown for every invalid value in turn:lanes:forward & turn:lanes:backward', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -570,7 +570,7 @@ describe('iD.Lanes', function() {
         });
 
         it.skip('fills with [\'unknown\'] when given turn:lanes are less than lanes count', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 5,
@@ -586,7 +586,7 @@ describe('iD.Lanes', function() {
         });
 
         it.skip('fills with [\'unknown\'] when given turn:lanes:forward are less than lanes forward count', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 5,
@@ -608,7 +608,7 @@ describe('iD.Lanes', function() {
         });
 
         it.skip('clips when turn lane information is more than lane count', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 2,
@@ -624,7 +624,7 @@ describe('iD.Lanes', function() {
         });
 
         it('turnLanes is undefined when not present', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 2,
@@ -641,7 +641,7 @@ describe('iD.Lanes', function() {
         });
 
         it('turnLanes.forward and turnLanes.backward are both undefined when both are not provided', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 2,
@@ -659,7 +659,7 @@ describe('iD.Lanes', function() {
         });
 
         it('parses turnLane correctly when lanes:both_ways=1', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 5,
@@ -678,7 +678,7 @@ describe('iD.Lanes', function() {
         });
 
         it('parses turnLane correctly when lanes:both_ways=1 & lanes:forward < lanes:backward', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 5,
@@ -697,7 +697,7 @@ describe('iD.Lanes', function() {
         });
 
         it('parses correctly when turn:lanes= ||x', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 3,
@@ -711,7 +711,7 @@ describe('iD.Lanes', function() {
         });
 
         it('parses correctly when turn:lanes= |x|', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 5,
@@ -724,7 +724,7 @@ describe('iD.Lanes', function() {
         });
 
         it('parses correctly when turn:lanes:forward= ||x', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 4,
@@ -743,7 +743,7 @@ describe('iD.Lanes', function() {
         });
 
         it('parses correctly when turn:lanes:backward= |', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 5,
@@ -762,7 +762,7 @@ describe('iD.Lanes', function() {
         });
 
         it('fills lanes.unspecified with key \'turnLane\' correctly', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 5,
@@ -779,7 +779,7 @@ describe('iD.Lanes', function() {
         });
 
         it('fills lanes.forward & lanes.backward with key \'turnLane\' correctly', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'tertiary',
                     lanes: 5,
@@ -803,7 +803,7 @@ describe('iD.Lanes', function() {
 
     describe('maxspeed', function() {
         it('should parse maxspeed without any units correctly', function() {
-            var maxspeed = iD.Way({
+            var maxspeed = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -811,7 +811,7 @@ describe('iD.Lanes', function() {
                 }
             }).lanes().metadata.maxspeed;
             expect(maxspeed).to.equal(70);
-            maxspeed = iD.Way({
+            maxspeed = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -822,7 +822,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should parse maxspeed with km/h correctly', function() {
-            var maxspeed = iD.Way({
+            var maxspeed = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -833,7 +833,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should parse maxspeed with kmh correctly', function() {
-            var maxspeed = iD.Way({
+            var maxspeed = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -844,7 +844,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should parse maxspeed with kph correctly', function() {
-            var maxspeed = iD.Way({
+            var maxspeed = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -855,7 +855,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should parse maxspeed with mph correctly', function() {
-            var maxspeed = iD.Way({
+            var maxspeed = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -866,7 +866,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should parse maxspeed with knots correctly', function() {
-            var maxspeed = iD.Way({
+            var maxspeed = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -877,7 +877,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should return undefined when incorrect maxspeed unit provided ', function() {
-            var maxspeed = iD.Way({
+            var maxspeed = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -888,7 +888,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should return undefined when incorrect maxspeed value provided ', function() {
-            var maxspeed = iD.Way({
+            var maxspeed = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -899,7 +899,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should return undefined when maxspeed not provided ', function() {
-            var maxspeed = iD.Way({
+            var maxspeed = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -912,7 +912,7 @@ describe('iD.Lanes', function() {
     describe('maxspeed:lanes', function() {
 
         it('should parse correctly', function() {
-            var maxspeedLanes = iD.Way({
+            var maxspeedLanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -925,7 +925,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should parse maxspeed:lanes:forward/backward correctly', function() {
-            var metadata = iD.Way({
+            var metadata = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -945,7 +945,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should parse correctly when some values maxspeed:lanes are implied by x||y notation', function() {
-            var maxspeedLanes = iD.Way({
+            var maxspeedLanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 4,
@@ -959,7 +959,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should parse correctly when some values maxspeed:lanes are implied by x||| notation', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -977,7 +977,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should return none for each maxspeed:lanes which equals maxspeed', function() {
-            var maxspeedLanes = iD.Way({
+            var maxspeedLanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -988,7 +988,7 @@ describe('iD.Lanes', function() {
             expect(maxspeedLanes.unspecified).to.deep.equal([
                 30, null, null, null, null
             ]);
-            maxspeedLanes = iD.Way({
+            maxspeedLanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -999,7 +999,7 @@ describe('iD.Lanes', function() {
             expect(maxspeedLanes.unspecified).to.deep.equal([
                 30, 40, 40, 40, 40
             ]);
-            maxspeedLanes = iD.Way({
+            maxspeedLanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -1013,7 +1013,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should return \'unknown\' for every invalid maxspeed:lane value', function() {
-            var maxspeedLanes = iD.Way({
+            var maxspeedLanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -1024,7 +1024,7 @@ describe('iD.Lanes', function() {
             expect(maxspeedLanes.unspecified).to.deep.equal([
                 null, 40, 'unknown', 40, 40
             ]);
-            maxspeedLanes = iD.Way({
+            maxspeedLanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -1039,7 +1039,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should parse maxspeed when none', function() {
-            var maxspeedLanes = iD.Way({
+            var maxspeedLanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -1052,7 +1052,7 @@ describe('iD.Lanes', function() {
         });
 
         it('fills lanes.unspecified with key \'maxspeed\' correctly', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -1071,7 +1071,7 @@ describe('iD.Lanes', function() {
 
     describe('bicycle lanes', function() {
         it('should parse bicycle:lanes correctly', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 3,
@@ -1093,7 +1093,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should parse bicycle:lanes:forward/backward correctly', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     'lanes:forward': 4,
@@ -1124,7 +1124,7 @@ describe('iD.Lanes', function() {
         });
 
         it('should replace any invalid value with unknown', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 3,
@@ -1147,7 +1147,7 @@ describe('iD.Lanes', function() {
 
     describe('miscellaneous lanes', function() {
         it('should parse psv:lanes correctly', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -1166,7 +1166,7 @@ describe('iD.Lanes', function() {
             ]);
         });
         it('should parse psv:lanes:forward/backward correctly', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 5,
@@ -1195,7 +1195,7 @@ describe('iD.Lanes', function() {
             ]);
         });
         it('should replace any invalid value with unknown', function() {
-            var lanes = iD.Way({
+            var lanes = iD.osmWay({
                 tags: {
                     highway: 'residential',
                     lanes: 3,
diff --git a/test/spec/osm/way.js b/test/spec/osm/way.js
index e52446d19..c53aa67e1 100644
--- a/test/spec/osm/way.js
+++ b/test/spec/osm/way.js
@@ -1,42 +1,42 @@
 describe('iD.osmWay', function() {
     if (iD.debug) {
         it('freezes nodes', function () {
-            expect(Object.isFrozen(iD.Way().nodes)).to.be.true;
+            expect(Object.isFrozen(iD.osmWay().nodes)).to.be.true;
         });
     }
 
     it('returns a way', function () {
-        expect(iD.Way()).to.be.an.instanceOf(iD.Way);
-        expect(iD.Way().type).to.equal('way');
+        expect(iD.osmWay()).to.be.an.instanceOf(iD.osmWay);
+        expect(iD.osmWay().type).to.equal('way');
     });
 
     it('defaults nodes to an empty array', function () {
-        expect(iD.Way().nodes).to.eql([]);
+        expect(iD.osmWay().nodes).to.eql([]);
     });
 
     it('sets nodes as specified', function () {
-        expect(iD.Way({nodes: ['n-1']}).nodes).to.eql(['n-1']);
+        expect(iD.osmWay({nodes: ['n-1']}).nodes).to.eql(['n-1']);
     });
 
     it('defaults tags to an empty object', function () {
-        expect(iD.Way().tags).to.eql({});
+        expect(iD.osmWay().tags).to.eql({});
     });
 
     it('sets tags as specified', function () {
-        expect(iD.Way({tags: {foo: 'bar'}}).tags).to.eql({foo: 'bar'});
+        expect(iD.osmWay({tags: {foo: 'bar'}}).tags).to.eql({foo: 'bar'});
     });
 
     describe('#copy', function () {
         it('returns a new Way', function () {
-            var w = iD.Way({id: 'w'}),
+            var w = iD.osmWay({id: 'w'}),
                 result = w.copy(null, {});
 
-            expect(result).to.be.an.instanceof(iD.Way);
+            expect(result).to.be.an.instanceof(iD.osmWay);
             expect(result).not.to.equal(w);
         });
 
         it('adds the new Way to input object', function () {
-            var w = iD.Way({id: 'w'}),
+            var w = iD.osmWay({id: 'w'}),
                 copies = {},
                 result = w.copy(null, copies);
             expect(Object.keys(copies)).to.have.length(1);
@@ -44,7 +44,7 @@ describe('iD.osmWay', function() {
         });
 
         it('returns an existing copy in input object', function () {
-            var w = iD.Way({id: 'w'}),
+            var w = iD.osmWay({id: 'w'}),
                 copies = {},
                 result1 = w.copy(null, copies),
                 result2 = w.copy(null, copies);
@@ -53,25 +53,25 @@ describe('iD.osmWay', function() {
         });
 
         it('deep copies nodes', function () {
-            var a = iD.Node({id: 'a'}),
-                b = iD.Node({id: 'b'}),
-                w = iD.Way({id: 'w', nodes: ['a', 'b']}),
-                graph = iD.Graph([a, b, w]),
+            var a = iD.osmNode({id: 'a'}),
+                b = iD.osmNode({id: 'b'}),
+                w = iD.osmWay({id: 'w', nodes: ['a', 'b']}),
+                graph = iD.coreGraph([a, b, w]),
                 copies = {},
                 result = w.copy(graph, copies);
 
             expect(Object.keys(copies)).to.have.length(3);
-            expect(copies.a).to.be.an.instanceof(iD.Node);
-            expect(copies.b).to.be.an.instanceof(iD.Node);
+            expect(copies.a).to.be.an.instanceof(iD.osmNode);
+            expect(copies.b).to.be.an.instanceof(iD.osmNode);
             expect(copies.a).not.to.equal(w.nodes[0]);
             expect(copies.b).not.to.equal(w.nodes[1]);
             expect(result.nodes).to.deep.eql([copies.a.id, copies.b.id]);
         });
 
         it('creates only one copy of shared nodes', function () {
-            var a = iD.Node({id: 'a'}),
-                w = iD.Way({id: 'w', nodes: ['a', 'a']}),
-                graph = iD.Graph([a, w]),
+            var a = iD.osmNode({id: 'a'}),
+                w = iD.osmWay({id: 'w', nodes: ['a', 'a']}),
+                graph = iD.coreGraph([a, w]),
                 copies = {},
                 result = w.copy(graph, copies);
 
@@ -81,70 +81,70 @@ describe('iD.osmWay', function() {
 
     describe('#first', function () {
         it('returns the first node', function () {
-            expect(iD.Way({nodes: ['a', 'b', 'c']}).first()).to.equal('a');
+            expect(iD.osmWay({nodes: ['a', 'b', 'c']}).first()).to.equal('a');
         });
     });
 
     describe('#last', function () {
         it('returns the last node', function () {
-            expect(iD.Way({nodes: ['a', 'b', 'c']}).last()).to.equal('c');
+            expect(iD.osmWay({nodes: ['a', 'b', 'c']}).last()).to.equal('c');
         });
     });
 
     describe('#contains', function () {
         it('returns true if the way contains the given node', function () {
-            expect(iD.Way({nodes: ['a', 'b', 'c']}).contains('b')).to.be.true;
+            expect(iD.osmWay({nodes: ['a', 'b', 'c']}).contains('b')).to.be.true;
         });
 
         it('returns false if the way does not contain the given node', function () {
-            expect(iD.Way({nodes: ['a', 'b', 'c']}).contains('d')).to.be.false;
+            expect(iD.osmWay({nodes: ['a', 'b', 'c']}).contains('d')).to.be.false;
         });
     });
 
     describe('#affix', function () {
         it('returns \'prefix\' if the way starts with the given node', function () {
-            expect(iD.Way({nodes: ['a', 'b', 'c']}).affix('a')).to.equal('prefix');
+            expect(iD.osmWay({nodes: ['a', 'b', 'c']}).affix('a')).to.equal('prefix');
         });
 
         it('returns \'suffix\' if the way ends with the given node', function () {
-            expect(iD.Way({nodes: ['a', 'b', 'c']}).affix('c')).to.equal('suffix');
+            expect(iD.osmWay({nodes: ['a', 'b', 'c']}).affix('c')).to.equal('suffix');
         });
 
         it('returns falsy if the way does not start or end with the given node', function () {
-            expect(iD.Way({nodes: ['a', 'b', 'c']}).affix('b')).not.to.be.ok;
-            expect(iD.Way({nodes: []}).affix('b')).not.to.be.ok;
+            expect(iD.osmWay({nodes: ['a', 'b', 'c']}).affix('b')).not.to.be.ok;
+            expect(iD.osmWay({nodes: []}).affix('b')).not.to.be.ok;
         });
     });
 
     describe('#extent', function () {
         it('returns the minimal extent containing all member nodes', function () {
-            var node1 = iD.Node({loc: [0, 0]}),
-                node2 = iD.Node({loc: [5, 10]}),
-                way   = iD.Way({nodes: [node1.id, node2.id]}),
-                graph = iD.Graph([node1, node2, way]);
+            var node1 = iD.osmNode({loc: [0, 0]}),
+                node2 = iD.osmNode({loc: [5, 10]}),
+                way   = iD.osmWay({nodes: [node1.id, node2.id]}),
+                graph = iD.coreGraph([node1, node2, way]);
             expect(way.extent(graph).equals([[0, 0], [5, 10]])).to.be.ok;
         });
     });
 
     describe('#isClosed', function() {
         it('returns false when the way contains no nodes', function() {
-            expect(iD.Way().isClosed()).to.be.false;
+            expect(iD.osmWay().isClosed()).to.be.false;
         });
 
         it('returns false when the way contains a single node', function() {
-            expect(iD.Way({ nodes: 'a'.split('') }).isClosed()).to.be.false;
+            expect(iD.osmWay({ nodes: 'a'.split('') }).isClosed()).to.be.false;
         });
 
         it('returns false when the way ends are not equal', function() {
-            expect(iD.Way({ nodes: 'abc'.split('') }).isClosed()).to.be.false;
+            expect(iD.osmWay({ nodes: 'abc'.split('') }).isClosed()).to.be.false;
         });
 
         it('returns true when the way ends are equal', function() {
-            expect(iD.Way({ nodes: 'aba'.split('') }).isClosed()).to.be.true;
+            expect(iD.osmWay({ nodes: 'aba'.split('') }).isClosed()).to.be.true;
         });
 
         it('returns true when the way contains two of the same node', function() {
-            expect(iD.Way({ nodes: 'aa'.split('') }).isClosed()).to.be.true;
+            expect(iD.osmWay({ nodes: 'aa'.split('') }).isClosed()).to.be.true;
         });
     });
 
@@ -155,13 +155,13 @@ describe('iD.osmWay', function() {
             //    |      a
             //    |     /
             //    c -- b
-            var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [ 0.0003,  0.0000]}),
-                iD.Node({id: 'b', loc: [ 0.0002, -0.0002]}),
-                iD.Node({id: 'c', loc: [-0.0002, -0.0002]}),
-                iD.Node({id: 'd', loc: [-0.0002,  0.0002]}),
-                iD.Node({id: 'e', loc: [ 0.0002,  0.0002]}),
-                iD.Way({id: 'w', nodes: ['a','b','c','d','e','a']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [ 0.0003,  0.0000]}),
+                iD.osmNode({id: 'b', loc: [ 0.0002, -0.0002]}),
+                iD.osmNode({id: 'c', loc: [-0.0002, -0.0002]}),
+                iD.osmNode({id: 'd', loc: [-0.0002,  0.0002]}),
+                iD.osmNode({id: 'e', loc: [ 0.0002,  0.0002]}),
+                iD.osmWay({id: 'w', nodes: ['a','b','c','d','e','a']})
             ]);
             expect(graph.entity('w').isConvex(graph)).to.be.true;
         });
@@ -172,13 +172,13 @@ describe('iD.osmWay', function() {
             //    |  a
             //    |   \
             //    c -- b
-            var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [ 0.0000,  0.0000]}),
-                iD.Node({id: 'b', loc: [ 0.0002, -0.0002]}),
-                iD.Node({id: 'c', loc: [-0.0002, -0.0002]}),
-                iD.Node({id: 'd', loc: [-0.0002,  0.0002]}),
-                iD.Node({id: 'e', loc: [ 0.0002,  0.0002]}),
-                iD.Way({id: 'w', nodes: ['a','b','c','d','e','a']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [ 0.0000,  0.0000]}),
+                iD.osmNode({id: 'b', loc: [ 0.0002, -0.0002]}),
+                iD.osmNode({id: 'c', loc: [-0.0002, -0.0002]}),
+                iD.osmNode({id: 'd', loc: [-0.0002,  0.0002]}),
+                iD.osmNode({id: 'e', loc: [ 0.0002,  0.0002]}),
+                iD.osmWay({id: 'w', nodes: ['a','b','c','d','e','a']})
             ]);
             expect(graph.entity('w').isConvex(graph)).to.be.false;
         });
@@ -189,21 +189,21 @@ describe('iD.osmWay', function() {
             //    |  a
             //    |   \
             //    c -- b
-            var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [ 0.0000,  0.0000]}),
-                iD.Node({id: 'b', loc: [ 0.0002, -0.0002]}),
-                iD.Node({id: 'c', loc: [-0.0002, -0.0002]}),
-                iD.Node({id: 'd', loc: [-0.0002,  0.0002]}),
-                iD.Node({id: 'e', loc: [ 0.0002,  0.0002]}),
-                iD.Way({id: 'w', nodes: ['a','b','c','d','e']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [ 0.0000,  0.0000]}),
+                iD.osmNode({id: 'b', loc: [ 0.0002, -0.0002]}),
+                iD.osmNode({id: 'c', loc: [-0.0002, -0.0002]}),
+                iD.osmNode({id: 'd', loc: [-0.0002,  0.0002]}),
+                iD.osmNode({id: 'e', loc: [ 0.0002,  0.0002]}),
+                iD.osmWay({id: 'w', nodes: ['a','b','c','d','e']})
             ]);
             expect(graph.entity('w').isConvex(graph)).to.be.null;
         });
 
         it('returns null for degenerate ways', function() {
-            var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [0.0000,  0.0000]}),
-                iD.Way({id: 'w', nodes: ['a','a']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [0.0000,  0.0000]}),
+                iD.osmWay({id: 'w', nodes: ['a','a']})
             ]);
             expect(graph.entity('w').isConvex(graph)).to.be.null;
         });
@@ -211,285 +211,285 @@ describe('iD.osmWay', function() {
 
     describe('#layer', function() {
         it('returns 0 when the way has no tags', function() {
-            expect(iD.Way().layer()).to.equal(0);
+            expect(iD.osmWay().layer()).to.equal(0);
         });
 
         it('returns 0 when the way has a non numeric layer tag', function() {
-            expect(iD.Way({tags: { layer: 'NaN' }}).layer()).to.equal(0);
-            expect(iD.Way({tags: { layer: 'Infinity' }}).layer()).to.equal(0);
-            expect(iD.Way({tags: { layer: 'Foo' }}).layer()).to.equal(0);
+            expect(iD.osmWay({tags: { layer: 'NaN' }}).layer()).to.equal(0);
+            expect(iD.osmWay({tags: { layer: 'Infinity' }}).layer()).to.equal(0);
+            expect(iD.osmWay({tags: { layer: 'Foo' }}).layer()).to.equal(0);
         });
 
         it('returns the layer when the way has an explicit layer tag', function() {
-            expect(iD.Way({tags: { layer: '2' }}).layer()).to.equal(2);
-            expect(iD.Way({tags: { layer: '-5' }}).layer()).to.equal(-5);
+            expect(iD.osmWay({tags: { layer: '2' }}).layer()).to.equal(2);
+            expect(iD.osmWay({tags: { layer: '-5' }}).layer()).to.equal(-5);
         });
 
         it('clamps the layer to within -10, 10', function() {
-            expect(iD.Way({tags: { layer: '12' }}).layer()).to.equal(10);
-            expect(iD.Way({tags: { layer: '-15' }}).layer()).to.equal(-10);
+            expect(iD.osmWay({tags: { layer: '12' }}).layer()).to.equal(10);
+            expect(iD.osmWay({tags: { layer: '-15' }}).layer()).to.equal(-10);
         });
 
         it('returns 1 for location=overground', function() {
-            expect(iD.Way({tags: { location: 'overground' }}).layer()).to.equal(1);
+            expect(iD.osmWay({tags: { location: 'overground' }}).layer()).to.equal(1);
         });
 
         it('returns -1 for covered=yes', function() {
-            expect(iD.Way({tags: { covered: 'yes' }}).layer()).to.equal(-1);
+            expect(iD.osmWay({tags: { covered: 'yes' }}).layer()).to.equal(-1);
         });
 
         it('returns -1 for location=underground', function() {
-            expect(iD.Way({tags: { location: 'underground' }}).layer()).to.equal(-1);
+            expect(iD.osmWay({tags: { location: 'underground' }}).layer()).to.equal(-1);
         });
 
         it('returns -10 for location=underwater', function() {
-            expect(iD.Way({tags: { location: 'underwater' }}).layer()).to.equal(-10);
+            expect(iD.osmWay({tags: { location: 'underwater' }}).layer()).to.equal(-10);
         });
 
         it('returns 10 for power lines', function() {
-            expect(iD.Way({tags: { power: 'line' }}).layer()).to.equal(10);
-            expect(iD.Way({tags: { power: 'minor_line' }}).layer()).to.equal(10);
+            expect(iD.osmWay({tags: { power: 'line' }}).layer()).to.equal(10);
+            expect(iD.osmWay({tags: { power: 'minor_line' }}).layer()).to.equal(10);
         });
 
         it('returns 10 for aerialways', function() {
-            expect(iD.Way({tags: { aerialway: 'cable_car' }}).layer()).to.equal(10);
+            expect(iD.osmWay({tags: { aerialway: 'cable_car' }}).layer()).to.equal(10);
         });
 
         it('returns 1 for bridges', function() {
-            expect(iD.Way({tags: { bridge: 'yes' }}).layer()).to.equal(1);
+            expect(iD.osmWay({tags: { bridge: 'yes' }}).layer()).to.equal(1);
         });
 
         it('returns -1 for cuttings', function() {
-            expect(iD.Way({tags: { cutting: 'yes' }}).layer()).to.equal(-1);
+            expect(iD.osmWay({tags: { cutting: 'yes' }}).layer()).to.equal(-1);
         });
 
         it('returns -1 for tunnels', function() {
-            expect(iD.Way({tags: { tunnel: 'yes' }}).layer()).to.equal(-1);
+            expect(iD.osmWay({tags: { tunnel: 'yes' }}).layer()).to.equal(-1);
         });
 
         it('returns -1 for waterways', function() {
-            expect(iD.Way({tags: { waterway: 'stream' }}).layer()).to.equal(-1);
+            expect(iD.osmWay({tags: { waterway: 'stream' }}).layer()).to.equal(-1);
         });
 
         it('returns -10 for pipelines', function() {
-            expect(iD.Way({tags: { man_made: 'pipeline' }}).layer()).to.equal(-10);
+            expect(iD.osmWay({tags: { man_made: 'pipeline' }}).layer()).to.equal(-10);
         });
 
         it('returns -10 for boundaries', function() {
-            expect(iD.Way({tags: { boundary: 'administrative' }}).layer()).to.equal(-10);
+            expect(iD.osmWay({tags: { boundary: 'administrative' }}).layer()).to.equal(-10);
         });
 
     });
 
     describe('#isOneWay', function() {
         it('returns false when the way has no tags', function() {
-            expect(iD.Way().isOneWay()).to.be.false;
+            expect(iD.osmWay().isOneWay()).to.be.false;
         });
 
         it('returns false when the way has tag oneway=no', function() {
-            expect(iD.Way({tags: { oneway: 'no' }}).isOneWay(), 'oneway no').to.be.false;
-            expect(iD.Way({tags: { oneway: '0' }}).isOneWay(), 'oneway 0').to.be.false;
+            expect(iD.osmWay({tags: { oneway: 'no' }}).isOneWay(), 'oneway no').to.be.false;
+            expect(iD.osmWay({tags: { oneway: '0' }}).isOneWay(), 'oneway 0').to.be.false;
         });
 
         it('returns true when the way has tag oneway=yes', function() {
-            expect(iD.Way({tags: { oneway: 'yes' }}).isOneWay(), 'oneway yes').to.be.true;
-            expect(iD.Way({tags: { oneway: '1' }}).isOneWay(), 'oneway 1').to.be.true;
-            expect(iD.Way({tags: { oneway: '-1' }}).isOneWay(), 'oneway -1').to.be.true;
+            expect(iD.osmWay({tags: { oneway: 'yes' }}).isOneWay(), 'oneway yes').to.be.true;
+            expect(iD.osmWay({tags: { oneway: '1' }}).isOneWay(), 'oneway 1').to.be.true;
+            expect(iD.osmWay({tags: { oneway: '-1' }}).isOneWay(), 'oneway -1').to.be.true;
         });
 
         it('returns true when the way has tag oneway=reversible', function() {
-            expect(iD.Way({tags: { oneway: 'reversible' }}).isOneWay(), 'oneway reversible').to.be.true;
+            expect(iD.osmWay({tags: { oneway: 'reversible' }}).isOneWay(), 'oneway reversible').to.be.true;
         });
 
         it('returns true when the way has tag oneway=alternating', function() {
-            expect(iD.Way({tags: { oneway: 'alternating' }}).isOneWay(), 'oneway alternating').to.be.true;
+            expect(iD.osmWay({tags: { oneway: 'alternating' }}).isOneWay(), 'oneway alternating').to.be.true;
         });
 
         it('returns true when the way has implied oneway tag (waterway=river, waterway=stream, etc)', function() {
-            expect(iD.Way({tags: { waterway: 'river' }}).isOneWay(), 'river').to.be.true;
-            expect(iD.Way({tags: { waterway: 'stream' }}).isOneWay(), 'stream').to.be.true;
-            expect(iD.Way({tags: { highway: 'motorway' }}).isOneWay(), 'motorway').to.be.true;
-            expect(iD.Way({tags: { junction: 'roundabout' }}).isOneWay(), 'roundabout').to.be.true;
-            expect(iD.Way({tags: { junction: 'circular' }}).isOneWay(), 'circular').to.be.true;
+            expect(iD.osmWay({tags: { waterway: 'river' }}).isOneWay(), 'river').to.be.true;
+            expect(iD.osmWay({tags: { waterway: 'stream' }}).isOneWay(), 'stream').to.be.true;
+            expect(iD.osmWay({tags: { highway: 'motorway' }}).isOneWay(), 'motorway').to.be.true;
+            expect(iD.osmWay({tags: { junction: 'roundabout' }}).isOneWay(), 'roundabout').to.be.true;
+            expect(iD.osmWay({tags: { junction: 'circular' }}).isOneWay(), 'circular').to.be.true;
         });
 
         it('returns false when the way does not have implied oneway tag', function() {
-            expect(iD.Way({tags: { highway: 'motorway_link' }}).isOneWay(), 'motorway_link').to.be.false;
-            expect(iD.Way({tags: { highway: 'trunk' }}).isOneWay(), 'trunk').to.be.false;
-            expect(iD.Way({tags: { highway: 'trunk_link' }}).isOneWay(), 'trunk_link').to.be.false;
-            expect(iD.Way({tags: { highway: 'primary' }}).isOneWay(), 'primary').to.be.false;
-            expect(iD.Way({tags: { highway: 'primary_link' }}).isOneWay(), 'primary_link').to.be.false;
-            expect(iD.Way({tags: { highway: 'secondary' }}).isOneWay(), 'secondary').to.be.false;
-            expect(iD.Way({tags: { highway: 'secondary_link' }}).isOneWay(), 'secondary_link').to.be.false;
-            expect(iD.Way({tags: { highway: 'tertiary' }}).isOneWay(), 'tertiary').to.be.false;
-            expect(iD.Way({tags: { highway: 'tertiary_link' }}).isOneWay(), 'tertiary_link').to.be.false;
-            expect(iD.Way({tags: { highway: 'unclassified' }}).isOneWay(), 'unclassified').to.be.false;
-            expect(iD.Way({tags: { highway: 'residential' }}).isOneWay(), 'residential').to.be.false;
-            expect(iD.Way({tags: { highway: 'living_street' }}).isOneWay(), 'living_street').to.be.false;
-            expect(iD.Way({tags: { highway: 'service' }}).isOneWay(), 'service').to.be.false;
-            expect(iD.Way({tags: { highway: 'track' }}).isOneWay(), 'track').to.be.false;
-            expect(iD.Way({tags: { highway: 'path' }}).isOneWay(), 'path').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'motorway_link' }}).isOneWay(), 'motorway_link').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'trunk' }}).isOneWay(), 'trunk').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'trunk_link' }}).isOneWay(), 'trunk_link').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'primary' }}).isOneWay(), 'primary').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'primary_link' }}).isOneWay(), 'primary_link').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'secondary' }}).isOneWay(), 'secondary').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'secondary_link' }}).isOneWay(), 'secondary_link').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'tertiary' }}).isOneWay(), 'tertiary').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'tertiary_link' }}).isOneWay(), 'tertiary_link').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'unclassified' }}).isOneWay(), 'unclassified').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'residential' }}).isOneWay(), 'residential').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'living_street' }}).isOneWay(), 'living_street').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'service' }}).isOneWay(), 'service').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'track' }}).isOneWay(), 'track').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'path' }}).isOneWay(), 'path').to.be.false;
         });
 
         it('returns false when oneway=no overrides implied oneway tag', function() {
-            expect(iD.Way({tags: { junction: 'roundabout', oneway: 'no' }}).isOneWay(), 'roundabout').to.be.false;
-            expect(iD.Way({tags: { junction: 'circular', oneway: 'no' }}).isOneWay(), 'circular').to.be.false;
-            expect(iD.Way({tags: { highway: 'motorway', oneway: 'no' }}).isOneWay(), 'motorway').to.be.false;
+            expect(iD.osmWay({tags: { junction: 'roundabout', oneway: 'no' }}).isOneWay(), 'roundabout').to.be.false;
+            expect(iD.osmWay({tags: { junction: 'circular', oneway: 'no' }}).isOneWay(), 'circular').to.be.false;
+            expect(iD.osmWay({tags: { highway: 'motorway', oneway: 'no' }}).isOneWay(), 'motorway').to.be.false;
         });
     });
 
     describe('#sidednessIdentifier', function() {
         it('returns tag when the tag has implied sidedness', function() {
-            expect(iD.Way({tags: { natural: 'cliff' }}).sidednessIdentifier()).to.eql('natural');
-            expect(iD.Way({tags: { natural: 'coastline' }}).sidednessIdentifier()).to.eql('coastline');
-            expect(iD.Way({tags: { barrier: 'retaining_wall' }}).sidednessIdentifier()).to.eql('barrier');
-            expect(iD.Way({tags: { barrier: 'kerb' }}).sidednessIdentifier()).to.eql('barrier');
-            expect(iD.Way({tags: { barrier: 'guard_rail' }}).sidednessIdentifier()).to.eql('barrier');
-            expect(iD.Way({tags: { barrier: 'city_wall' }}).sidednessIdentifier()).to.eql('barrier');
-            expect(iD.Way({tags: { man_made: 'embankment' }}).sidednessIdentifier()).to.eql('man_made');
+            expect(iD.osmWay({tags: { natural: 'cliff' }}).sidednessIdentifier()).to.eql('natural');
+            expect(iD.osmWay({tags: { natural: 'coastline' }}).sidednessIdentifier()).to.eql('coastline');
+            expect(iD.osmWay({tags: { barrier: 'retaining_wall' }}).sidednessIdentifier()).to.eql('barrier');
+            expect(iD.osmWay({tags: { barrier: 'kerb' }}).sidednessIdentifier()).to.eql('barrier');
+            expect(iD.osmWay({tags: { barrier: 'guard_rail' }}).sidednessIdentifier()).to.eql('barrier');
+            expect(iD.osmWay({tags: { barrier: 'city_wall' }}).sidednessIdentifier()).to.eql('barrier');
+            expect(iD.osmWay({tags: { man_made: 'embankment' }}).sidednessIdentifier()).to.eql('man_made');
         });
 
         it('returns null when tag does not have implied sidedness', function() {
-            expect(iD.Way({tags: { natural: 'ridge' }}).sidednessIdentifier()).to.be.null;
-            expect(iD.Way({tags: { barrier: 'fence' }}).sidednessIdentifier()).to.be.null;
-            expect(iD.Way({tags: { man_made: 'dyke' }}).sidednessIdentifier()).to.be.null;
-            expect(iD.Way({tags: { highway: 'motorway' }}).sidednessIdentifier()).to.be.null;
+            expect(iD.osmWay({tags: { natural: 'ridge' }}).sidednessIdentifier()).to.be.null;
+            expect(iD.osmWay({tags: { barrier: 'fence' }}).sidednessIdentifier()).to.be.null;
+            expect(iD.osmWay({tags: { man_made: 'dyke' }}).sidednessIdentifier()).to.be.null;
+            expect(iD.osmWay({tags: { highway: 'motorway' }}).sidednessIdentifier()).to.be.null;
         });
     });
     describe('#isSided', function() {
         it('returns false when the way has no tags', function() {
-            expect(iD.Way().isSided()).to.be.false;
+            expect(iD.osmWay().isSided()).to.be.false;
         });
 
         it('returns false when the way has two_sided=yes', function() {
-            expect(iD.Way({tags: { two_sided: 'yes' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { two_sided: 'yes' }}).isSided()).to.be.false;
         });
 
         it('returns true when the tag has implied sidedness', function() {
-            expect(iD.Way({tags: { natural: 'cliff' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { natural: 'coastline' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { barrier: 'retaining_wall' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { barrier: 'kerb' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { barrier: 'guard_rail' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { barrier: 'city_wall' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { man_made: 'embankment' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { natural: 'cliff' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { natural: 'coastline' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { barrier: 'retaining_wall' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { barrier: 'kerb' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { barrier: 'guard_rail' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { barrier: 'city_wall' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { man_made: 'embankment' }}).isSided()).to.be.true;
         });
 
         it('returns false when two_sided=yes overrides tag with implied sidedness', function() {
-            expect(iD.Way({tags: { natural: 'cliff', two_sided: 'yes' }}).isSided()).to.be.false;
-            expect(iD.Way({tags: { natural: 'coastline', two_sided: 'yes' }}).isSided()).to.be.false;
-            expect(iD.Way({tags: { barrier: 'retaining_wall', two_sided: 'yes' }}).isSided()).to.be.false;
-            expect(iD.Way({tags: { barrier: 'kerb', two_sided: 'yes' }}).isSided()).to.be.false;
-            expect(iD.Way({tags: { barrier: 'guard_rail', two_sided: 'yes' }}).isSided()).to.be.false;
-            expect(iD.Way({tags: { barrier: 'city_wall', two_sided: 'yes' }}).isSided()).to.be.false;
-            expect(iD.Way({tags: { man_made: 'embankment', two_sided: 'yes' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { natural: 'cliff', two_sided: 'yes' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { natural: 'coastline', two_sided: 'yes' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { barrier: 'retaining_wall', two_sided: 'yes' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { barrier: 'kerb', two_sided: 'yes' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { barrier: 'guard_rail', two_sided: 'yes' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { barrier: 'city_wall', two_sided: 'yes' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { man_made: 'embankment', two_sided: 'yes' }}).isSided()).to.be.false;
         });
 
         it('returns true when two_sided=no is on tag with implied sidedness', function() {
-            expect(iD.Way({tags: { natural: 'cliff', two_sided: 'no' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { natural: 'coastline', two_sided: 'no' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { barrier: 'retaining_wall', two_sided: 'no' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { barrier: 'kerb', two_sided: 'no' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { barrier: 'guard_rail', two_sided: 'no' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { barrier: 'city_wall', two_sided: 'no' }}).isSided()).to.be.true;
-            expect(iD.Way({tags: { man_made: 'embankment', two_sided: 'no' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { natural: 'cliff', two_sided: 'no' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { natural: 'coastline', two_sided: 'no' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { barrier: 'retaining_wall', two_sided: 'no' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { barrier: 'kerb', two_sided: 'no' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { barrier: 'guard_rail', two_sided: 'no' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { barrier: 'city_wall', two_sided: 'no' }}).isSided()).to.be.true;
+            expect(iD.osmWay({tags: { man_made: 'embankment', two_sided: 'no' }}).isSided()).to.be.true;
         });
 
         it('returns false when the tag does not have implied sidedness', function() {
-            expect(iD.Way({tags: { natural: 'ridge' }}).isSided()).to.be.false;
-            expect(iD.Way({tags: { barrier: 'fence' }}).isSided()).to.be.false;
-            expect(iD.Way({tags: { man_made: 'dyke' }}).isSided()).to.be.false;
-            expect(iD.Way({tags: { highway: 'motorway' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { natural: 'ridge' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { barrier: 'fence' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { man_made: 'dyke' }}).isSided()).to.be.false;
+            expect(iD.osmWay({tags: { highway: 'motorway' }}).isSided()).to.be.false;
         });
     });
 
     describe('#isArea', function() {
         before(function() {
-            iD.Context();
+            iD.coreContext();
         });
 
         it('returns false when the way has no tags', function() {
-            expect(iD.Way().isArea()).to.equal(false);
+            expect(iD.osmWay().isArea()).to.equal(false);
         });
 
         it('returns true if the way has tag area=yes', function() {
-            expect(iD.Way({tags: { area: 'yes' }}).isArea()).to.equal(true);
+            expect(iD.osmWay({tags: { area: 'yes' }}).isArea()).to.equal(true);
         });
 
         it('returns false if the way is closed and has no tags', function() {
-            expect(iD.Way({nodes: ['n1', 'n1']}).isArea()).to.equal(false);
+            expect(iD.osmWay({nodes: ['n1', 'n1']}).isArea()).to.equal(false);
         });
 
         it('returns true if the way is closed and has a key in iD.areaKeys', function() {
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: {building: 'yes'}}).isArea()).to.equal(true);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: {building: 'yes'}}).isArea()).to.equal(true);
         });
 
         it('returns true for some highway and railway exceptions', function() {
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: { highway: 'services' }}).isArea(), 'highway=services').to.equal(true);
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: { highway: 'rest_area' }}).isArea(), 'highway=rest_area').to.equal(true);
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: { railway: 'roundhouse' }}).isArea(), 'railway=roundhouse').to.equal(true);
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: { railway: 'station' }}).isArea(), 'railway=station').to.equal(true);
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: { railway: 'traverser' }}).isArea(), 'railway=traverser').to.equal(true);
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: { railway: 'turntable' }}).isArea(), 'railway=turntable').to.equal(true);
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: { railway: 'wash' }}).isArea(), 'railway=wash').to.equal(true);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: { highway: 'services' }}).isArea(), 'highway=services').to.equal(true);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: { highway: 'rest_area' }}).isArea(), 'highway=rest_area').to.equal(true);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: { railway: 'roundhouse' }}).isArea(), 'railway=roundhouse').to.equal(true);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: { railway: 'station' }}).isArea(), 'railway=station').to.equal(true);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: { railway: 'traverser' }}).isArea(), 'railway=traverser').to.equal(true);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: { railway: 'turntable' }}).isArea(), 'railway=turntable').to.equal(true);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: { railway: 'wash' }}).isArea(), 'railway=wash').to.equal(true);
         });
 
         it('returns false if the way is closed and has no keys in iD.areaKeys', function() {
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: {a: 'b'}}).isArea()).to.equal(false);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: {a: 'b'}}).isArea()).to.equal(false);
         });
 
         it('returns false if the way is closed and has tag area=no', function() {
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: {area: 'no', building: 'yes'}}).isArea()).to.equal(false);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: {area: 'no', building: 'yes'}}).isArea()).to.equal(false);
         });
 
         it('returns false for coastline', function() {
-            expect(iD.Way({nodes: ['n1', 'n1'], tags: {natural: 'coastline'}}).isArea()).to.equal(false);
+            expect(iD.osmWay({nodes: ['n1', 'n1'], tags: {natural: 'coastline'}}).isArea()).to.equal(false);
         });
     });
 
     describe('#isDegenerate', function() {
        it('returns true for a linear way with zero or one nodes', function () {
-           expect(iD.Way({nodes: []}).isDegenerate()).to.equal(true);
-           expect(iD.Way({nodes: ['a']}).isDegenerate()).to.equal(true);
+           expect(iD.osmWay({nodes: []}).isDegenerate()).to.equal(true);
+           expect(iD.osmWay({nodes: ['a']}).isDegenerate()).to.equal(true);
        });
 
         it('returns true for a circular way with only one unique node', function () {
-            expect(iD.Way({nodes: ['a', 'a']}).isDegenerate()).to.equal(true);
+            expect(iD.osmWay({nodes: ['a', 'a']}).isDegenerate()).to.equal(true);
         });
 
         it('returns false for a linear way with two or more nodes', function () {
-            expect(iD.Way({nodes: ['a', 'b']}).isDegenerate()).to.equal(false);
+            expect(iD.osmWay({nodes: ['a', 'b']}).isDegenerate()).to.equal(false);
         });
 
         it('returns true for an area with zero, one, or two unique nodes', function () {
-            expect(iD.Way({tags: {area: 'yes'}, nodes: []}).isDegenerate()).to.equal(true);
-            expect(iD.Way({tags: {area: 'yes'}, nodes: ['a', 'a']}).isDegenerate()).to.equal(true);
-            expect(iD.Way({tags: {area: 'yes'}, nodes: ['a', 'b', 'a']}).isDegenerate()).to.equal(true);
+            expect(iD.osmWay({tags: {area: 'yes'}, nodes: []}).isDegenerate()).to.equal(true);
+            expect(iD.osmWay({tags: {area: 'yes'}, nodes: ['a', 'a']}).isDegenerate()).to.equal(true);
+            expect(iD.osmWay({tags: {area: 'yes'}, nodes: ['a', 'b', 'a']}).isDegenerate()).to.equal(true);
         });
 
         it('returns false for an area with three or more unique nodes', function () {
-            expect(iD.Way({tags: {area: 'yes'}, nodes: ['a', 'b', 'c', 'a']}).isDegenerate()).to.equal(false);
+            expect(iD.osmWay({tags: {area: 'yes'}, nodes: ['a', 'b', 'c', 'a']}).isDegenerate()).to.equal(false);
         });
     });
 
     describe('#areAdjacent', function() {
         it('returns false for nodes not in the way', function() {
-            expect(iD.Way().areAdjacent('a', 'b')).to.equal(false);
+            expect(iD.osmWay().areAdjacent('a', 'b')).to.equal(false);
         });
 
         it('returns false for non-adjacent nodes in the way', function() {
-            expect(iD.Way({nodes: ['a', 'b', 'c']}).areAdjacent('a', 'c')).to.equal(false);
+            expect(iD.osmWay({nodes: ['a', 'b', 'c']}).areAdjacent('a', 'c')).to.equal(false);
         });
 
         it('returns true for adjacent nodes in the way (forward)', function() {
-            var way = iD.Way({nodes: ['a', 'b', 'c', 'd']});
+            var way = iD.osmWay({nodes: ['a', 'b', 'c', 'd']});
             expect(way.areAdjacent('a', 'b')).to.equal(true);
             expect(way.areAdjacent('b', 'c')).to.equal(true);
             expect(way.areAdjacent('c', 'd')).to.equal(true);
         });
 
         it('returns true for adjacent nodes in the way (reverse)', function() {
-            var way = iD.Way({nodes: ['a', 'b', 'c', 'd']});
+            var way = iD.osmWay({nodes: ['a', 'b', 'c', 'd']});
             expect(way.areAdjacent('b', 'a')).to.equal(true);
             expect(way.areAdjacent('c', 'b')).to.equal(true);
             expect(way.areAdjacent('d', 'c')).to.equal(true);
@@ -498,488 +498,488 @@ describe('iD.osmWay', function() {
 
     describe('#geometry', function() {
         it('returns \'line\' when the way is not an area', function () {
-            expect(iD.Way().geometry(iD.Graph())).to.equal('line');
+            expect(iD.osmWay().geometry(iD.coreGraph())).to.equal('line');
         });
 
         it('returns \'area\' when the way is an area', function () {
-            expect(iD.Way({tags: { area: 'yes' }}).geometry(iD.Graph())).to.equal('area');
+            expect(iD.osmWay({tags: { area: 'yes' }}).geometry(iD.coreGraph())).to.equal('area');
         });
     });
 
     describe('#close', function () {
         it('returns self for empty way', function () {
-            var w = iD.Way();
+            var w = iD.osmWay();
             expect(w.close()).to.deep.equal(w);
         });
 
         it('returns self for already closed way', function () {
-            var w1 = iD.Way({ nodes: 'aba'.split('') });
+            var w1 = iD.osmWay({ nodes: 'aba'.split('') });
             expect(w1.close()).to.deep.equal(w1);
-            var w2 = iD.Way({ nodes: 'aa'.split('') });
+            var w2 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w2.close()).to.deep.equal(w2);
         });
 
         it('closes a way', function () {
-            var w1 = iD.Way({ nodes: 'ab'.split('') });
+            var w1 = iD.osmWay({ nodes: 'ab'.split('') });
             expect(w1.close().nodes.join('')).to.eql('aba', 'multiple');
-            var w2 = iD.Way({ nodes: 'a'.split('') });
+            var w2 = iD.osmWay({ nodes: 'a'.split('') });
             expect(w2.close().nodes.join('')).to.eql('aa', 'single');
         });
 
         it('eliminates duplicate consecutive nodes when closing a linear way', function () {
-            var w1 = iD.Way({ nodes: 'abb'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abb'.split('') });
             expect(w1.close().nodes.join('')).to.eql('aba', 'duplicate at end');
-            var w2 = iD.Way({ nodes: 'abbc'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbc'.split('') });
             expect(w2.close().nodes.join('')).to.eql('abca', 'duplicate in middle');
-            var w3 = iD.Way({ nodes: 'aabc'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabc'.split('') });
             expect(w3.close().nodes.join('')).to.eql('abca', 'duplicate at beginning');
-            var w4 = iD.Way({ nodes: 'abbbcbb'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abbbcbb'.split('') });
             expect(w4.close().nodes.join('')).to.eql('abcba', 'duplicates multiple places');
         });
     });
 
     describe('#unclose', function () {
         it('returns self for empty way', function () {
-            var w = iD.Way();
+            var w = iD.osmWay();
             expect(w.unclose()).to.deep.equal(w);
         });
 
         it('returns self for already unclosed way', function () {
-            var w1 = iD.Way({ nodes: 'a'.split('') });
+            var w1 = iD.osmWay({ nodes: 'a'.split('') });
             expect(w1.unclose()).to.deep.equal(w1);
-            var w2 = iD.Way({ nodes: 'ab'.split('') });
+            var w2 = iD.osmWay({ nodes: 'ab'.split('') });
             expect(w2.unclose()).to.deep.equal(w2);
         });
 
         it('uncloses a circular way', function () {
-            var w1 = iD.Way({ nodes: 'aba'.split('') });
+            var w1 = iD.osmWay({ nodes: 'aba'.split('') });
             expect(w1.unclose().nodes.join('')).to.eql('ab', 'multiple');
-            var w2 = iD.Way({ nodes: 'aa'.split('') });
+            var w2 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w2.unclose().nodes.join('')).to.eql('a', 'single');
         });
 
         it('eliminates duplicate consecutive nodes when unclosing a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcca'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcca'.split('') });
             expect(w1.unclose().nodes.join('')).to.eql('abc', 'duplicate internal node at end');
-            var w2 = iD.Way({ nodes: 'abbca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbca'.split('') });
             expect(w2.unclose().nodes.join('')).to.eql('abc', 'duplicate internal node in middle');
-            var w3 = iD.Way({ nodes: 'aabca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w3.unclose().nodes.join('')).to.eql('abc', 'duplicate connector node at beginning');
-            var w4 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w4.unclose().nodes.join('')).to.eql('abc', 'duplicate connector node at end');
-            var w5 = iD.Way({ nodes: 'abbbcbba'.split('') });
+            var w5 = iD.osmWay({ nodes: 'abbbcbba'.split('') });
             expect(w5.unclose().nodes.join('')).to.eql('abcb', 'duplicates multiple places');
-            var w6 = iD.Way({ nodes: 'aa'.split('') });
+            var w6 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w6.unclose().nodes.join('')).to.eql('a', 'single node circular');
-            var w7 = iD.Way({ nodes: 'aaa'.split('') });
+            var w7 = iD.osmWay({ nodes: 'aaa'.split('') });
             expect(w7.unclose().nodes.join('')).to.eql('a', 'single node circular with duplicates');
         });
     });
 
     describe('#addNode', function () {
         it('adds a node to an empty way', function () {
-            var w = iD.Way();
+            var w = iD.osmWay();
             expect(w.addNode('a').nodes).to.eql(['a']);
         });
 
         it('adds a node to the end of a linear way when index is undefined', function () {
-            var w = iD.Way({ nodes: 'ab'.split('') });
+            var w = iD.osmWay({ nodes: 'ab'.split('') });
             expect(w.addNode('c').nodes.join('')).to.eql('abc');
         });
 
         it('adds a node before the end connector of a circular way when index is undefined', function () {
-            var w1 = iD.Way({ nodes: 'aba'.split('') });
+            var w1 = iD.osmWay({ nodes: 'aba'.split('') });
             expect(w1.addNode('c').nodes.join('')).to.eql('abca', 'circular');
-            var w2 = iD.Way({ nodes: 'aa'.split('') });
+            var w2 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w2.addNode('c').nodes.join('')).to.eql('aca', 'single node circular');
         });
 
         it('adds an internal node to a linear way at a positive index', function () {
-            var w = iD.Way({ nodes: 'ab'.split('') });
+            var w = iD.osmWay({ nodes: 'ab'.split('') });
             expect(w.addNode('c', 1).nodes.join('')).to.eql('acb');
         });
 
         it('adds an internal node to a circular way at a positive index', function () {
-            var w1 = iD.Way({ nodes: 'aba'.split('') });
+            var w1 = iD.osmWay({ nodes: 'aba'.split('') });
             expect(w1.addNode('c', 1).nodes.join('')).to.eql('acba', 'circular');
-            var w2 = iD.Way({ nodes: 'aa'.split('') });
+            var w2 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w2.addNode('c', 1).nodes.join('')).to.eql('aca', 'single node circular');
         });
 
         it('adds a leading node to a linear way at index 0', function () {
-            var w = iD.Way({ nodes: 'ab'.split('') });
+            var w = iD.osmWay({ nodes: 'ab'.split('') });
             expect(w.addNode('c', 0).nodes.join('')).to.eql('cab');
         });
 
         it('adds a leading node to a circular way at index 0, preserving circularity', function () {
-            var w1 = iD.Way({ nodes: 'aba'.split('') });
+            var w1 = iD.osmWay({ nodes: 'aba'.split('') });
             expect(w1.addNode('c', 0).nodes.join('')).to.eql('cabc', 'circular');
-            var w2 = iD.Way({ nodes: 'aa'.split('') });
+            var w2 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w2.addNode('c', 0).nodes.join('')).to.eql('cac', 'single node circular');
         });
 
         it('throws RangeError if index outside of array range for linear way', function () {
-            var w = iD.Way({ nodes: 'ab'.split('') });
+            var w = iD.osmWay({ nodes: 'ab'.split('') });
             expect(w.addNode.bind(w, 'c', 3)).to.throw(RangeError, /out of range 0\.\.2/, 'over range');
             expect(w.addNode.bind(w, 'c', -1)).to.throw(RangeError, /out of range 0\.\.2/, 'under range');
         });
 
         it('throws RangeError if index outside of array range for circular way', function () {
-            var w = iD.Way({ nodes: 'aba'.split('') });
+            var w = iD.osmWay({ nodes: 'aba'.split('') });
             expect(w.addNode.bind(w, 'c', 3)).to.throw(RangeError, /out of range 0\.\.2/, 'over range');
             expect(w.addNode.bind(w, 'c', -1)).to.throw(RangeError, /out of range 0\.\.2/, 'under range');
         });
 
         it('eliminates duplicate consecutive nodes when adding to the end of a linear way', function () {
-            var w1 = iD.Way({ nodes: 'abb'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abb'.split('') });
             expect(w1.addNode('b').nodes.join('')).to.eql('ab', 'duplicate at end');
-            var w2 = iD.Way({ nodes: 'abbc'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbc'.split('') });
             expect(w2.addNode('c').nodes.join('')).to.eql('abc', 'duplicate in middle');
-            var w3 = iD.Way({ nodes: 'aabc'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabc'.split('') });
             expect(w3.addNode('c').nodes.join('')).to.eql('abc', 'duplicate at beginning');
-            var w4 = iD.Way({ nodes: 'abbbcbb'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abbbcbb'.split('') });
             expect(w4.addNode('b').nodes.join('')).to.eql('abcb', 'duplicates multiple places');
         });
 
         it('eliminates duplicate consecutive nodes when adding same node before the end connector of a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcca'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcca'.split('') });
             expect(w1.addNode('c').nodes.join('')).to.eql('abca', 'duplicate internal node at end');
-            var w2 = iD.Way({ nodes: 'abbca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbca'.split('') });
             expect(w2.addNode('c').nodes.join('')).to.eql('abca', 'duplicate internal node in middle');
-            var w3 = iD.Way({ nodes: 'aabca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w3.addNode('c').nodes.join('')).to.eql('abca', 'duplicate connector node at beginning');
-            var w4 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w4.addNode('a').nodes.join('')).to.eql('abca', 'duplicate connector node at end');
-            var w5 = iD.Way({ nodes: 'abbbcbba'.split('') });
+            var w5 = iD.osmWay({ nodes: 'abbbcbba'.split('') });
             expect(w5.addNode('b').nodes.join('')).to.eql('abcba', 'duplicates multiple places');
-            var w6 = iD.Way({ nodes: 'aa'.split('') });
+            var w6 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w6.addNode('a').nodes.join('')).to.eql('aa', 'single node circular');
-            var w7 = iD.Way({ nodes: 'aaa'.split('') });
+            var w7 = iD.osmWay({ nodes: 'aaa'.split('') });
             expect(w7.addNode('a').nodes.join('')).to.eql('aa', 'single node circular with duplicates');
         });
 
         it('eliminates duplicate consecutive nodes when adding different node before the end connector of a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcca'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcca'.split('') });
             expect(w1.addNode('d').nodes.join('')).to.eql('abcda', 'duplicate internal node at end');
-            var w2 = iD.Way({ nodes: 'abbca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbca'.split('') });
             expect(w2.addNode('d').nodes.join('')).to.eql('abcda', 'duplicate internal node in middle');
-            var w3 = iD.Way({ nodes: 'aabca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w3.addNode('d').nodes.join('')).to.eql('abcda', 'duplicate connector node at beginning');
-            var w4 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w4.addNode('d').nodes.join('')).to.eql('abcda', 'duplicate connector node at end');
-            var w5 = iD.Way({ nodes: 'abbbcbba'.split('') });
+            var w5 = iD.osmWay({ nodes: 'abbbcbba'.split('') });
             expect(w5.addNode('d').nodes.join('')).to.eql('abcbda', 'duplicates multiple places');
-            var w6 = iD.Way({ nodes: 'aa'.split('') });
+            var w6 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w6.addNode('d').nodes.join('')).to.eql('ada', 'single node circular');
-            var w7 = iD.Way({ nodes: 'aaa'.split('') });
+            var w7 = iD.osmWay({ nodes: 'aaa'.split('') });
             expect(w7.addNode('d').nodes.join('')).to.eql('ada', 'single node circular with duplicates');
         });
 
         it('eliminates duplicate consecutive nodes when adding to the beginning of a linear way', function () {
-            var w1 = iD.Way({ nodes: 'abb'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abb'.split('') });
             expect(w1.addNode('a', 0).nodes.join('')).to.eql('ab', 'duplicate at end');
-            var w2 = iD.Way({ nodes: 'abbc'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbc'.split('') });
             expect(w2.addNode('a', 0).nodes.join('')).to.eql('abc', 'duplicate in middle');
-            var w3 = iD.Way({ nodes: 'aabc'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabc'.split('') });
             expect(w3.addNode('a', 0).nodes.join('')).to.eql('abc', 'duplicate at beginning');
-            var w4 = iD.Way({ nodes: 'abbbcbb'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abbbcbb'.split('') });
             expect(w4.addNode('a', 0).nodes.join('')).to.eql('abcb', 'duplicates multiple places');
         });
 
         it('eliminates duplicate consecutive nodes when adding same node as beginning connector a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcca'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcca'.split('') });
             expect(w1.addNode('a', 0).nodes.join('')).to.eql('abca', 'duplicate internal node at end');
-            var w2 = iD.Way({ nodes: 'abbca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbca'.split('') });
             expect(w2.addNode('a', 0).nodes.join('')).to.eql('abca', 'duplicate internal node in middle');
-            var w3 = iD.Way({ nodes: 'aabca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w3.addNode('a', 0).nodes.join('')).to.eql('abca', 'duplicate connector node at beginning');
-            var w4 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w4.addNode('a', 0).nodes.join('')).to.eql('abca', 'duplicate connector node at end');
-            var w5 = iD.Way({ nodes: 'abbbcbba'.split('') });
+            var w5 = iD.osmWay({ nodes: 'abbbcbba'.split('') });
             expect(w5.addNode('a', 0).nodes.join('')).to.eql('abcba', 'duplicates multiple places');
-            var w6 = iD.Way({ nodes: 'aa'.split('') });
+            var w6 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w6.addNode('a', 0).nodes.join('')).to.eql('aa', 'single node circular');
-            var w7 = iD.Way({ nodes: 'aaa'.split('') });
+            var w7 = iD.osmWay({ nodes: 'aaa'.split('') });
             expect(w7.addNode('a', 0).nodes.join('')).to.eql('aa', 'single node circular with duplicates');
         });
 
         it('eliminates duplicate consecutive nodes when adding different node as beginning connector of a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcca'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcca'.split('') });
             expect(w1.addNode('d', 0).nodes.join('')).to.eql('dabcd', 'duplicate internal node at end');
-            var w2 = iD.Way({ nodes: 'abbca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbca'.split('') });
             expect(w2.addNode('d', 0).nodes.join('')).to.eql('dabcd', 'duplicate internal node in middle');
-            var w3 = iD.Way({ nodes: 'aabca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w3.addNode('d', 0).nodes.join('')).to.eql('dabcd', 'duplicate connector node at beginning');
-            var w4 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w4.addNode('d', 0).nodes.join('')).to.eql('dabcd', 'duplicate connector node at end');
-            var w5 = iD.Way({ nodes: 'abbbcbba'.split('') });
+            var w5 = iD.osmWay({ nodes: 'abbbcbba'.split('') });
             expect(w5.addNode('d', 0).nodes.join('')).to.eql('dabcbd', 'duplicates multiple places');
-            var w6 = iD.Way({ nodes: 'aa'.split('') });
+            var w6 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w6.addNode('d', 0).nodes.join('')).to.eql('dad', 'single node circular');
-            var w7 = iD.Way({ nodes: 'aaa'.split('') });
+            var w7 = iD.osmWay({ nodes: 'aaa'.split('') });
             expect(w7.addNode('d', 0).nodes.join('')).to.eql('dad', 'single node circular with duplicates');
         });
     });
 
     describe('#updateNode', function () {
         it('throws RangeError if empty way', function () {
-            var w = iD.Way();
+            var w = iD.osmWay();
             expect(w.updateNode.bind(w, 'd', 0)).to.throw(RangeError, /out of range 0\.\.-1/);
         });
 
         it('updates an internal node on a linear way at a positive index', function () {
-            var w = iD.Way({ nodes: 'ab'.split('') });
+            var w = iD.osmWay({ nodes: 'ab'.split('') });
             expect(w.updateNode('d', 1).nodes.join('')).to.eql('ad');
         });
 
         it('updates an internal node on a circular way at a positive index', function () {
-            var w = iD.Way({ nodes: 'aba'.split('') });
+            var w = iD.osmWay({ nodes: 'aba'.split('') });
             expect(w.updateNode('d', 1).nodes.join('')).to.eql('ada', 'circular');
         });
 
         it('updates a leading node on a linear way at index 0', function () {
-            var w = iD.Way({ nodes: 'ab'.split('') });
+            var w = iD.osmWay({ nodes: 'ab'.split('') });
             expect(w.updateNode('d', 0).nodes.join('')).to.eql('db');
         });
 
         it('updates a leading node on a circular way at index 0, preserving circularity', function () {
-            var w1 = iD.Way({ nodes: 'aba'.split('') });
+            var w1 = iD.osmWay({ nodes: 'aba'.split('') });
             expect(w1.updateNode('d', 0).nodes.join('')).to.eql('dbd', 'circular');
-            var w2 = iD.Way({ nodes: 'aa'.split('') });
+            var w2 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w2.updateNode('d', 0).nodes.join('')).to.eql('dd', 'single node circular');
         });
 
         it('throws RangeError if index outside of array range for linear way', function () {
-            var w = iD.Way({ nodes: 'ab'.split('') });
+            var w = iD.osmWay({ nodes: 'ab'.split('') });
             expect(w.updateNode.bind(w, 'd', 2)).to.throw(RangeError, /out of range 0\.\.1/, 'over range');
             expect(w.updateNode.bind(w, 'd', -1)).to.throw(RangeError, /out of range 0\.\.1/, 'under range');
         });
 
         it('throws RangeError if index outside of array range for circular way', function () {
-            var w = iD.Way({ nodes: 'aba'.split('') });
+            var w = iD.osmWay({ nodes: 'aba'.split('') });
             expect(w.updateNode.bind(w, 'd', 3)).to.throw(RangeError, /out of range 0\.\.2/, 'over range');
             expect(w.updateNode.bind(w, 'd', -1)).to.throw(RangeError, /out of range 0\.\.2/, 'under range');
         });
 
         it('eliminates duplicate consecutive nodes when updating the end of a linear way', function () {
-            var w1 = iD.Way({ nodes: 'abcc'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcc'.split('') });
             expect(w1.updateNode('c', 3).nodes.join('')).to.eql('abc', 'duplicate at end');
-            var w2 = iD.Way({ nodes: 'abbc'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbc'.split('') });
             expect(w2.updateNode('c', 3).nodes.join('')).to.eql('abc', 'duplicate in middle');
-            var w3 = iD.Way({ nodes: 'aabc'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabc'.split('') });
             expect(w3.updateNode('c', 3).nodes.join('')).to.eql('abc', 'duplicate at beginning');
-            var w4 = iD.Way({ nodes: 'abbbcbb'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abbbcbb'.split('') });
             expect(w4.updateNode('b', 6).nodes.join('')).to.eql('abcb', 'duplicates multiple places');
         });
 
         it('eliminates duplicate consecutive nodes when updating same node before the end connector of a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcca'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcca'.split('') });
             expect(w1.updateNode('c', 3).nodes.join('')).to.eql('abca', 'duplicate internal node at end');
-            var w2 = iD.Way({ nodes: 'abbca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbca'.split('') });
             expect(w2.updateNode('c', 3).nodes.join('')).to.eql('abca', 'duplicate internal node in middle');
-            var w3 = iD.Way({ nodes: 'aabca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w3.updateNode('c', 3).nodes.join('')).to.eql('abca', 'duplicate connector node at beginning');
-            var w4 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w4.updateNode('a', 3).nodes.join('')).to.eql('abca', 'duplicate connector node at end');
-            var w5 = iD.Way({ nodes: 'abbbcbba'.split('') });
+            var w5 = iD.osmWay({ nodes: 'abbbcbba'.split('') });
             expect(w5.updateNode('b', 6).nodes.join('')).to.eql('abcba', 'duplicates multiple places');
         });
 
         it('eliminates duplicate consecutive nodes when updating different node before the end connector of a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcca'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcca'.split('') });
             expect(w1.updateNode('d', 3).nodes.join('')).to.eql('abcda', 'duplicate internal node at end');
-            var w2 = iD.Way({ nodes: 'abbca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbca'.split('') });
             expect(w2.updateNode('d', 3).nodes.join('')).to.eql('abda', 'duplicate internal node in middle');
-            var w3 = iD.Way({ nodes: 'aabca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w3.updateNode('d', 3).nodes.join('')).to.eql('abda', 'duplicate connector node at beginning');
-            var w4 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w4.updateNode('d', 3).nodes.join('')).to.eql('dbcd', 'duplicate connector node at end');
-            var w5 = iD.Way({ nodes: 'abbbcbba'.split('') });
+            var w5 = iD.osmWay({ nodes: 'abbbcbba'.split('') });
             expect(w5.updateNode('d', 6).nodes.join('')).to.eql('abcbda', 'duplicates multiple places');
         });
 
         it('eliminates duplicate consecutive nodes when updating the beginning of a linear way', function () {
-            var w1 = iD.Way({ nodes: 'abb'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abb'.split('') });
             expect(w1.updateNode('b', 0).nodes.join('')).to.eql('b', 'duplicate at end');
-            var w2 = iD.Way({ nodes: 'abbc'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbc'.split('') });
             expect(w2.updateNode('b', 0).nodes.join('')).to.eql('bc', 'duplicate in middle');
-            var w3 = iD.Way({ nodes: 'aabc'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabc'.split('') });
             expect(w3.updateNode('a', 0).nodes.join('')).to.eql('abc', 'duplicate at beginning');
-            var w4 = iD.Way({ nodes: 'abbbcbb'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abbbcbb'.split('') });
             expect(w4.updateNode('a', 0).nodes.join('')).to.eql('abcb', 'duplicates multiple places');
         });
 
         it('eliminates duplicate consecutive nodes when updating same node as beginning connector a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcca'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcca'.split('') });
             expect(w1.updateNode('a', 0).nodes.join('')).to.eql('abca', 'duplicate internal node at end');
-            var w2 = iD.Way({ nodes: 'abbca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbca'.split('') });
             expect(w2.updateNode('a', 0).nodes.join('')).to.eql('abca', 'duplicate internal node in middle');
-            var w3 = iD.Way({ nodes: 'aabca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w3.updateNode('a', 0).nodes.join('')).to.eql('abca', 'duplicate connector node at beginning');
-            var w4 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w4.updateNode('a', 0).nodes.join('')).to.eql('abca', 'duplicate connector node at end');
-            var w5 = iD.Way({ nodes: 'abbbcbba'.split('') });
+            var w5 = iD.osmWay({ nodes: 'abbbcbba'.split('') });
             expect(w5.updateNode('a', 0).nodes.join('')).to.eql('abcba', 'duplicates multiple places');
-            var w6 = iD.Way({ nodes: 'aa'.split('') });
+            var w6 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w6.updateNode('a', 0).nodes.join('')).to.eql('aa', 'single node circular');
-            var w7 = iD.Way({ nodes: 'aaa'.split('') });
+            var w7 = iD.osmWay({ nodes: 'aaa'.split('') });
             expect(w7.updateNode('a', 0).nodes.join('')).to.eql('aa', 'single node circular with duplicates');
         });
 
         it('eliminates duplicate consecutive nodes when updating different node as beginning connector of a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcca'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcca'.split('') });
             expect(w1.updateNode('d', 0).nodes.join('')).to.eql('dbcd', 'duplicate internal node at end');
-            var w2 = iD.Way({ nodes: 'abbca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbca'.split('') });
             expect(w2.updateNode('d', 0).nodes.join('')).to.eql('dbcd', 'duplicate internal node in middle');
-            var w3 = iD.Way({ nodes: 'aabca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w3.updateNode('d', 0).nodes.join('')).to.eql('dbcd', 'duplicate connector node at beginning');
-            var w4 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w4.updateNode('d', 0).nodes.join('')).to.eql('dbcd', 'duplicate connector node at end');
-            var w5 = iD.Way({ nodes: 'abbbcbba'.split('') });
+            var w5 = iD.osmWay({ nodes: 'abbbcbba'.split('') });
             expect(w5.updateNode('d', 0).nodes.join('')).to.eql('dbcbd', 'duplicates multiple places');
-            var w6 = iD.Way({ nodes: 'aa'.split('') });
+            var w6 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w6.updateNode('d', 0).nodes.join('')).to.eql('dd', 'single node circular');
-            var w7 = iD.Way({ nodes: 'aaa'.split('') });
+            var w7 = iD.osmWay({ nodes: 'aaa'.split('') });
             expect(w7.updateNode('d', 0).nodes.join('')).to.eql('dd', 'single node circular with duplicates');
         });
 
         it('eliminates duplicate consecutive nodes when updating different node as ending connector of a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcca'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcca'.split('') });
             expect(w1.updateNode('d', 4).nodes.join('')).to.eql('dbcd', 'duplicate internal node at end');
-            var w2 = iD.Way({ nodes: 'abbca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abbca'.split('') });
             expect(w2.updateNode('d', 4).nodes.join('')).to.eql('dbcd', 'duplicate internal node in middle');
-            var w3 = iD.Way({ nodes: 'aabca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w3.updateNode('d', 4).nodes.join('')).to.eql('dbcd', 'duplicate connector node at beginning');
-            var w4 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w4.updateNode('d', 4).nodes.join('')).to.eql('dbcd', 'duplicate connector node at end');
-            var w5 = iD.Way({ nodes: 'abbbcbba'.split('') });
+            var w5 = iD.osmWay({ nodes: 'abbbcbba'.split('') });
             expect(w5.updateNode('d', 7).nodes.join('')).to.eql('dbcbd', 'duplicates multiple places');
-            var w6 = iD.Way({ nodes: 'aa'.split('') });
+            var w6 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w6.updateNode('d', 1).nodes.join('')).to.eql('dd', 'single node circular');
-            var w7 = iD.Way({ nodes: 'aaa'.split('') });
+            var w7 = iD.osmWay({ nodes: 'aaa'.split('') });
             expect(w7.updateNode('d', 2).nodes.join('')).to.eql('dd', 'single node circular with duplicates');
         });
     });
 
     describe('#replaceNode', function () {
         it('replaces a node', function () {
-            var w1 = iD.Way({ nodes: 'a'.split('') });
+            var w1 = iD.osmWay({ nodes: 'a'.split('') });
             expect(w1.replaceNode('a','b').nodes.join('')).to.eql('b', 'single replace, single node');
-            var w2 = iD.Way({ nodes: 'abc'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abc'.split('') });
             expect(w2.replaceNode('b','d').nodes.join('')).to.eql('adc', 'single replace, linear');
-            var w4 = iD.Way({ nodes: 'abca'.split('') });
+            var w4 = iD.osmWay({ nodes: 'abca'.split('') });
             expect(w4.replaceNode('b','d').nodes.join('')).to.eql('adca', 'single replace, circular');
         });
 
         it('replaces multiply occurring nodes', function () {
-            var w1 = iD.Way({ nodes: 'abcb'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcb'.split('') });
             expect(w1.replaceNode('b','d').nodes.join('')).to.eql('adcd', 'multiple replace, linear');
-            var w2 = iD.Way({ nodes: 'abca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abca'.split('') });
             expect(w2.replaceNode('a','d').nodes.join('')).to.eql('dbcd', 'multiple replace, circular');
-            var w3 = iD.Way({ nodes: 'aa'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w3.replaceNode('a','d').nodes.join('')).to.eql('dd', 'multiple replace, single node circular');
         });
 
         it('eliminates duplicate consecutive nodes when replacing along a linear way', function () {
-            var w1 = iD.Way({ nodes: 'abbcd'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abbcd'.split('') });
             expect(w1.replaceNode('c','b').nodes.join('')).to.eql('abd', 'duplicate before');
-            var w2 = iD.Way({ nodes: 'abcdd'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abcdd'.split('') });
             expect(w2.replaceNode('c','d').nodes.join('')).to.eql('abd', 'duplicate after');
-            var w3 = iD.Way({ nodes: 'abbcbb'.split('')});
+            var w3 = iD.osmWay({ nodes: 'abbcbb'.split('')});
             expect(w3.replaceNode('c','b').nodes.join('')).to.eql('ab', 'duplicate before and after');
         });
 
         it('eliminates duplicate consecutive nodes when replacing internal nodes along a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abbcda'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abbcda'.split('') });
             expect(w1.replaceNode('c','b').nodes.join('')).to.eql('abda', 'duplicate before');
-            var w2 = iD.Way({ nodes: 'abcdda'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abcdda'.split('') });
             expect(w2.replaceNode('c','d').nodes.join('')).to.eql('abda', 'duplicate after');
-            var w3 = iD.Way({ nodes: 'abbcbba'.split('')});
+            var w3 = iD.osmWay({ nodes: 'abbcbba'.split('')});
             expect(w3.replaceNode('c','b').nodes.join('')).to.eql('aba', 'duplicate before and after');
         });
 
         it('eliminates duplicate consecutive nodes when replacing adjacent to connecting nodes along a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcda'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcda'.split('') });
             expect(w1.replaceNode('d','a').nodes.join('')).to.eql('abca', 'before single end connector');
-            var w2 = iD.Way({ nodes: 'abcda'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abcda'.split('') });
             expect(w2.replaceNode('b','a').nodes.join('')).to.eql('acda', 'after single beginning connector');
-            var w3 = iD.Way({ nodes: 'abcdaa'.split('') });
+            var w3 = iD.osmWay({ nodes: 'abcdaa'.split('') });
             expect(w3.replaceNode('d','a').nodes.join('')).to.eql('abca', 'before duplicate end connector');
-            var w4 = iD.Way({ nodes: 'aabcda'.split('') });
+            var w4 = iD.osmWay({ nodes: 'aabcda'.split('') });
             expect(w4.replaceNode('b','a').nodes.join('')).to.eql('acda', 'after duplicate beginning connector');
         });
 
         it('eliminates duplicate consecutive nodes when replacing connecting nodes along a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w1.replaceNode('a','d').nodes.join('')).to.eql('dbcd', 'duplicate end connector');
-            var w2 = iD.Way({ nodes: 'aabca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w2.replaceNode('a','d').nodes.join('')).to.eql('dbcd', 'duplicate beginning connector');
-            var w3 = iD.Way({ nodes: 'aabcaa'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabcaa'.split('') });
             expect(w3.replaceNode('a','d').nodes.join('')).to.eql('dbcd', 'duplicate beginning and end connectors');
-            var w4 = iD.Way({ nodes: 'aabaacaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'aabaacaa'.split('') });
             expect(w4.replaceNode('a','d').nodes.join('')).to.eql('dbdcd', 'duplicates multiple places');
         });
     });
 
     describe('#removeNode', function () {
         it('removes a node', function () {
-            var w1 = iD.Way({ nodes: 'a'.split('') });
+            var w1 = iD.osmWay({ nodes: 'a'.split('') });
             expect(w1.removeNode('a').nodes.join('')).to.eql('', 'single remove, single node');
-            var w2 = iD.Way({ nodes: 'abc'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abc'.split('') });
             expect(w2.removeNode('b').nodes.join('')).to.eql('ac', 'single remove, linear');
-            var w3 = iD.Way({ nodes: 'abca'.split('') });
+            var w3 = iD.osmWay({ nodes: 'abca'.split('') });
             expect(w3.removeNode('b').nodes.join('')).to.eql('aca', 'single remove, circular');
-            var w4 = iD.Way({ nodes: 'aa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'aa'.split('') });
             expect(w4.removeNode('a').nodes.join('')).to.eql('', 'multiple remove, single node circular');
         });
 
         it('removes multiply occurring nodes', function () {
-            var w1 = iD.Way({ nodes: 'abcb'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcb'.split('') });
             expect(w1.removeNode('b').nodes.join('')).to.eql('ac', 'multiple remove, linear');
-            var w2 = iD.Way({ nodes: 'abcba'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abcba'.split('') });
             expect(w2.removeNode('b').nodes.join('')).to.eql('aca', 'multiple remove, circular');
         });
 
         it('eliminates duplicate consecutive nodes when removing along a linear way', function () {
-            var w1 = iD.Way({ nodes: 'abbcd'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abbcd'.split('') });
             expect(w1.removeNode('c').nodes.join('')).to.eql('abd', 'duplicate before');
-            var w2 = iD.Way({ nodes: 'abcdd'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abcdd'.split('') });
             expect(w2.removeNode('c').nodes.join('')).to.eql('abd', 'duplicate after');
-            var w3 = iD.Way({ nodes: 'abbcbb'.split('')});
+            var w3 = iD.osmWay({ nodes: 'abbcbb'.split('')});
             expect(w3.removeNode('c').nodes.join('')).to.eql('ab', 'duplicate before and after');
         });
 
         it('eliminates duplicate consecutive nodes when removing internal nodes along a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abbcda'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abbcda'.split('') });
             expect(w1.removeNode('c').nodes.join('')).to.eql('abda', 'duplicate before');
-            var w2 = iD.Way({ nodes: 'abcdda'.split('') });
+            var w2 = iD.osmWay({ nodes: 'abcdda'.split('') });
             expect(w2.removeNode('c').nodes.join('')).to.eql('abda', 'duplicate after');
-            var w3 = iD.Way({ nodes: 'abbcbba'.split('')});
+            var w3 = iD.osmWay({ nodes: 'abbcbba'.split('')});
             expect(w3.removeNode('c').nodes.join('')).to.eql('aba', 'duplicate before and after');
         });
 
         it('eliminates duplicate consecutive nodes when removing adjacent to connecting nodes along a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcdaa'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcdaa'.split('') });
             expect(w1.removeNode('d').nodes.join('')).to.eql('abca', 'duplicate end connector');
-            var w2 = iD.Way({ nodes: 'aabcda'.split('') });
+            var w2 = iD.osmWay({ nodes: 'aabcda'.split('') });
             expect(w2.removeNode('b').nodes.join('')).to.eql('acda', 'duplicate beginning connector');
         });
 
         it('eliminates duplicate consecutive nodes when removing connecting nodes along a circular way', function () {
-            var w1 = iD.Way({ nodes: 'abcaa'.split('') });
+            var w1 = iD.osmWay({ nodes: 'abcaa'.split('') });
             expect(w1.removeNode('a').nodes.join('')).to.eql('bcb', 'duplicate end connector');
-            var w2 = iD.Way({ nodes: 'aabca'.split('') });
+            var w2 = iD.osmWay({ nodes: 'aabca'.split('') });
             expect(w2.removeNode('a').nodes.join('')).to.eql('bcb', 'duplicate beginning connector');
-            var w3 = iD.Way({ nodes: 'aabcaa'.split('') });
+            var w3 = iD.osmWay({ nodes: 'aabcaa'.split('') });
             expect(w3.removeNode('a').nodes.join('')).to.eql('bcb', 'duplicate beginning and end connectors');
-            var w4 = iD.Way({ nodes: 'aabaacaa'.split('') });
+            var w4 = iD.osmWay({ nodes: 'aabaacaa'.split('') });
             expect(w4.removeNode('a').nodes.join('')).to.eql('bcb', 'duplicates multiple places');
         });
     });
 
     describe('#asJXON', function () {
         it('converts a way to jxon', function() {
-            var node = iD.Way({id: 'w-1', nodes: ['n1', 'n2'], tags: {highway: 'residential'}});
+            var node = iD.osmWay({id: 'w-1', nodes: ['n1', 'n2'], tags: {highway: 'residential'}});
             expect(node.asJXON()).to.eql({way: {
                 '@id': '-1',
                 '@version': 0,
@@ -988,16 +988,16 @@ describe('iD.osmWay', function() {
         });
 
         it('includes changeset if provided', function() {
-            expect(iD.Way().asJXON('1234').way['@changeset']).to.equal('1234');
+            expect(iD.osmWay().asJXON('1234').way['@changeset']).to.equal('1234');
         });
     });
 
     describe('#asGeoJSON', function () {
         it('converts a line to a GeoJSON LineString geometry', function () {
-            var a = iD.Node({loc: [1, 2]}),
-                b = iD.Node({loc: [3, 4]}),
-                w = iD.Way({tags: {highway: 'residential'}, nodes: [a.id, b.id]}),
-                graph = iD.Graph([a, b, w]),
+            var a = iD.osmNode({loc: [1, 2]}),
+                b = iD.osmNode({loc: [3, 4]}),
+                w = iD.osmWay({tags: {highway: 'residential'}, nodes: [a.id, b.id]}),
+                graph = iD.coreGraph([a, b, w]),
                 json = w.asGeoJSON(graph);
 
             expect(json.type).to.equal('LineString');
@@ -1005,11 +1005,11 @@ describe('iD.osmWay', function() {
         });
 
         it('converts an area to a GeoJSON Polygon geometry', function () {
-            var a = iD.Node({loc: [1, 2]}),
-                b = iD.Node({loc: [5, 6]}),
-                c = iD.Node({loc: [3, 4]}),
-                w = iD.Way({tags: {area: 'yes'}, nodes: [a.id, b.id, c.id, a.id]}),
-                graph = iD.Graph([a, b, c, w]),
+            var a = iD.osmNode({loc: [1, 2]}),
+                b = iD.osmNode({loc: [5, 6]}),
+                c = iD.osmNode({loc: [3, 4]}),
+                w = iD.osmWay({tags: {area: 'yes'}, nodes: [a.id, b.id, c.id, a.id]}),
+                graph = iD.coreGraph([a, b, c, w]),
                 json = w.asGeoJSON(graph, true);
 
             expect(json.type).to.equal('Polygon');
@@ -1017,11 +1017,11 @@ describe('iD.osmWay', function() {
         });
 
         it('converts an unclosed area to a GeoJSON LineString geometry', function () {
-            var a = iD.Node({loc: [1, 2]}),
-                b = iD.Node({loc: [5, 6]}),
-                c = iD.Node({loc: [3, 4]}),
-                w = iD.Way({tags: {area: 'yes'}, nodes: [a.id, b.id, c.id]}),
-                graph = iD.Graph([a, b, c, w]),
+            var a = iD.osmNode({loc: [1, 2]}),
+                b = iD.osmNode({loc: [5, 6]}),
+                c = iD.osmNode({loc: [3, 4]}),
+                w = iD.osmWay({tags: {area: 'yes'}, nodes: [a.id, b.id, c.id]}),
+                graph = iD.coreGraph([a, b, c, w]),
                 json = w.asGeoJSON(graph, true);
 
             expect(json.type).to.equal('LineString');
@@ -1031,17 +1031,17 @@ describe('iD.osmWay', function() {
 
     describe('#area', function() {
         it('returns a relative measure of area', function () {
-            var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [-0.0002,  0.0001]}),
-                iD.Node({id: 'b', loc: [ 0.0002,  0.0001]}),
-                iD.Node({id: 'c', loc: [ 0.0002, -0.0001]}),
-                iD.Node({id: 'd', loc: [-0.0002, -0.0001]}),
-                iD.Node({id: 'e', loc: [-0.0004,  0.0002]}),
-                iD.Node({id: 'f', loc: [ 0.0004,  0.0002]}),
-                iD.Node({id: 'g', loc: [ 0.0004, -0.0002]}),
-                iD.Node({id: 'h', loc: [-0.0004, -0.0002]}),
-                iD.Way({id: 's', tags: {area: 'yes'}, nodes: ['a', 'b', 'c', 'd', 'a']}),
-                iD.Way({id: 'l', tags: {area: 'yes'}, nodes: ['e', 'f', 'g', 'h', 'e']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [-0.0002,  0.0001]}),
+                iD.osmNode({id: 'b', loc: [ 0.0002,  0.0001]}),
+                iD.osmNode({id: 'c', loc: [ 0.0002, -0.0001]}),
+                iD.osmNode({id: 'd', loc: [-0.0002, -0.0001]}),
+                iD.osmNode({id: 'e', loc: [-0.0004,  0.0002]}),
+                iD.osmNode({id: 'f', loc: [ 0.0004,  0.0002]}),
+                iD.osmNode({id: 'g', loc: [ 0.0004, -0.0002]}),
+                iD.osmNode({id: 'h', loc: [-0.0004, -0.0002]}),
+                iD.osmWay({id: 's', tags: {area: 'yes'}, nodes: ['a', 'b', 'c', 'd', 'a']}),
+                iD.osmWay({id: 'l', tags: {area: 'yes'}, nodes: ['e', 'f', 'g', 'h', 'e']})
             ]);
 
             var s = Math.abs(graph.entity('s').area(graph)),
@@ -1051,13 +1051,13 @@ describe('iD.osmWay', function() {
         });
 
         it('treats unclosed areas as if they were closed', function () {
-            var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [-0.0002,  0.0001]}),
-                iD.Node({id: 'b', loc: [ 0.0002,  0.0001]}),
-                iD.Node({id: 'c', loc: [ 0.0002, -0.0001]}),
-                iD.Node({id: 'd', loc: [-0.0002, -0.0001]}),
-                iD.Way({id: 's', tags: {area: 'yes'}, nodes: ['a', 'b', 'c', 'd', 'a']}),
-                iD.Way({id: 'l', tags: {area: 'yes'}, nodes: ['a', 'b', 'c', 'd']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [-0.0002,  0.0001]}),
+                iD.osmNode({id: 'b', loc: [ 0.0002,  0.0001]}),
+                iD.osmNode({id: 'c', loc: [ 0.0002, -0.0001]}),
+                iD.osmNode({id: 'd', loc: [-0.0002, -0.0001]}),
+                iD.osmWay({id: 's', tags: {area: 'yes'}, nodes: ['a', 'b', 'c', 'd', 'a']}),
+                iD.osmWay({id: 'l', tags: {area: 'yes'}, nodes: ['a', 'b', 'c', 'd']})
             ]);
 
             var s = graph.entity('s').area(graph),
@@ -1067,12 +1067,12 @@ describe('iD.osmWay', function() {
         });
 
         it('returns 0 for degenerate areas', function () {
-            var graph = iD.Graph([
-                iD.Node({id: 'a', loc: [-0.0002,  0.0001]}),
-                iD.Node({id: 'b', loc: [ 0.0002,  0.0001]}),
-                iD.Way({id: '0', tags: {area: 'yes'}, nodes: []}),
-                iD.Way({id: '1', tags: {area: 'yes'}, nodes: ['a']}),
-                iD.Way({id: '2', tags: {area: 'yes'}, nodes: ['a', 'b']})
+            var graph = iD.coreGraph([
+                iD.osmNode({id: 'a', loc: [-0.0002,  0.0001]}),
+                iD.osmNode({id: 'b', loc: [ 0.0002,  0.0001]}),
+                iD.osmWay({id: '0', tags: {area: 'yes'}, nodes: []}),
+                iD.osmWay({id: '1', tags: {area: 'yes'}, nodes: ['a']}),
+                iD.osmWay({id: '2', tags: {area: 'yes'}, nodes: ['a', 'b']})
             ]);
 
             expect(graph.entity('0').area(graph)).to.equal(0);
diff --git a/test/spec/presets/index.js b/test/spec/presets/index.js
index 670cd5d28..4c0d4696f 100644
--- a/test/spec/presets/index.js
+++ b/test/spec/presets/index.js
@@ -224,17 +224,6 @@ describe('iD.presetIndex', function () {
 
 
     describe('#fromExternal', function () {
-        var origPresets = {
-            presets: {
-                area: { name: 'Area', tags: {}, geometry: ['area'] },
-                line: { name: 'Line', tags: {}, geometry: ['line'] },
-                point: { name: 'Point', tags: {}, geometry: ['point'] },
-                vertex: { name: 'Vertex', tags: {}, geometry: ['vertex'] },
-                relation: { name: 'Relation', tags: {}, geometry: ['relation'] },
-                building: { name: 'Building', tags: { building: 'yes' }, geometry: ['area'] }
-            }
-        };
-
         var morePresets = {
             presets: {
                 '8bc64d6d': {
diff --git a/test/spec/renderer/features.js b/test/spec/renderer/features.js
index d93e5ade9..f8488d32a 100644
--- a/test/spec/renderer/features.js
+++ b/test/spec/renderer/features.js
@@ -13,7 +13,7 @@ describe('iD.Features', function() {
     }
 
     beforeEach(function() {
-        context = iD.Context();
+        context = iD.coreContext();
         d3.select(document.createElement('div'))
             .attr('id', 'map')
             .call(context.map());
@@ -63,16 +63,16 @@ describe('iD.Features', function() {
 
     describe('#gatherStats', function() {
         it('counts features', function() {
-            var graph = iD.Graph([
-                    iD.Node({id: 'point_bar', tags: {amenity: 'bar'}, version: 1}),
-                    iD.Node({id: 'point_dock', tags: {waterway: 'dock'}, version: 1}),
-                    iD.Node({id: 'point_rail_station', tags: {railway: 'station'}, version: 1}),
-                    iD.Node({id: 'point_generator', tags: {power: 'generator'}, version: 1}),
-                    iD.Node({id: 'point_old_rail_station', tags: {railway: 'station', disused: 'yes'}, version: 1}),
-                    iD.Way({id: 'motorway', tags: {highway: 'motorway'}, version: 1}),
-                    iD.Way({id: 'building_yes', tags: {area: 'yes', amenity: 'school', building: 'yes'}, version: 1}),
-                    iD.Way({id: 'boundary', tags: {boundary: 'administrative'}, version: 1}),
-                    iD.Way({id: 'fence', tags: {barrier: 'fence'}, version: 1})
+            var graph = iD.coreGraph([
+                    iD.osmNode({id: 'point_bar', tags: {amenity: 'bar'}, version: 1}),
+                    iD.osmNode({id: 'point_dock', tags: {waterway: 'dock'}, version: 1}),
+                    iD.osmNode({id: 'point_rail_station', tags: {railway: 'station'}, version: 1}),
+                    iD.osmNode({id: 'point_generator', tags: {power: 'generator'}, version: 1}),
+                    iD.osmNode({id: 'point_old_rail_station', tags: {railway: 'station', disused: 'yes'}, version: 1}),
+                    iD.osmWay({id: 'motorway', tags: {highway: 'motorway'}, version: 1}),
+                    iD.osmWay({id: 'building_yes', tags: {area: 'yes', amenity: 'school', building: 'yes'}, version: 1}),
+                    iD.osmWay({id: 'boundary', tags: {boundary: 'administrative'}, version: 1}),
+                    iD.osmWay({id: 'fence', tags: {barrier: 'fence'}, version: 1})
                 ]),
                 all = _values(graph.base().entities),
                 stats;
@@ -96,64 +96,64 @@ describe('iD.Features', function() {
     });
 
     describe('matching', function() {
-        var graph = iD.Graph([
+        var graph = iD.coreGraph([
             // Points
-            iD.Node({id: 'point_bar', tags: {amenity: 'bar'}, version: 1}),
-            iD.Node({id: 'point_dock', tags: {waterway: 'dock'}, version: 1}),
-            iD.Node({id: 'point_rail_station', tags: {railway: 'station'}, version: 1}),
-            iD.Node({id: 'point_generator', tags: {power: 'generator'}, version: 1}),
-            iD.Node({id: 'point_old_rail_station', tags: {railway: 'station', disused: 'yes'}, version: 1}),
+            iD.osmNode({id: 'point_bar', tags: {amenity: 'bar'}, version: 1}),
+            iD.osmNode({id: 'point_dock', tags: {waterway: 'dock'}, version: 1}),
+            iD.osmNode({id: 'point_rail_station', tags: {railway: 'station'}, version: 1}),
+            iD.osmNode({id: 'point_generator', tags: {power: 'generator'}, version: 1}),
+            iD.osmNode({id: 'point_old_rail_station', tags: {railway: 'station', disused: 'yes'}, version: 1}),
 
             // Traffic Roads
-            iD.Way({id: 'motorway', tags: {highway: 'motorway'}, version: 1}),
-            iD.Way({id: 'motorway_link', tags: {highway: 'motorway_link'}, version: 1}),
-            iD.Way({id: 'trunk', tags: {highway: 'trunk'}, version: 1}),
-            iD.Way({id: 'trunk_link', tags: {highway: 'trunk_link'}, version: 1}),
-            iD.Way({id: 'primary', tags: {highway: 'primary'}, version: 1}),
-            iD.Way({id: 'primary_link', tags: {highway: 'primary_link'}, version: 1}),
-            iD.Way({id: 'secondary', tags: {highway: 'secondary'}, version: 1}),
-            iD.Way({id: 'secondary_link', tags: {highway: 'secondary_link'}, version: 1}),
-            iD.Way({id: 'tertiary', tags: {highway: 'tertiary'}, version: 1}),
-            iD.Way({id: 'tertiary_link', tags: {highway: 'tertiary_link'}, version: 1}),
-            iD.Way({id: 'residential', tags: {highway: 'residential'}, version: 1}),
-            iD.Way({id: 'unclassified', tags: {highway: 'unclassified'}, version: 1}),
-            iD.Way({id: 'living_street', tags: {highway: 'living_street'}, version: 1}),
+            iD.osmWay({id: 'motorway', tags: {highway: 'motorway'}, version: 1}),
+            iD.osmWay({id: 'motorway_link', tags: {highway: 'motorway_link'}, version: 1}),
+            iD.osmWay({id: 'trunk', tags: {highway: 'trunk'}, version: 1}),
+            iD.osmWay({id: 'trunk_link', tags: {highway: 'trunk_link'}, version: 1}),
+            iD.osmWay({id: 'primary', tags: {highway: 'primary'}, version: 1}),
+            iD.osmWay({id: 'primary_link', tags: {highway: 'primary_link'}, version: 1}),
+            iD.osmWay({id: 'secondary', tags: {highway: 'secondary'}, version: 1}),
+            iD.osmWay({id: 'secondary_link', tags: {highway: 'secondary_link'}, version: 1}),
+            iD.osmWay({id: 'tertiary', tags: {highway: 'tertiary'}, version: 1}),
+            iD.osmWay({id: 'tertiary_link', tags: {highway: 'tertiary_link'}, version: 1}),
+            iD.osmWay({id: 'residential', tags: {highway: 'residential'}, version: 1}),
+            iD.osmWay({id: 'unclassified', tags: {highway: 'unclassified'}, version: 1}),
+            iD.osmWay({id: 'living_street', tags: {highway: 'living_street'}, version: 1}),
 
             // Service Roads
-            iD.Way({id: 'service', tags: {highway: 'service'}, version: 1}),
-            iD.Way({id: 'road', tags: {highway: 'road'}, version: 1}),
-            iD.Way({id: 'track', tags: {highway: 'track'}, version: 1}),
+            iD.osmWay({id: 'service', tags: {highway: 'service'}, version: 1}),
+            iD.osmWay({id: 'road', tags: {highway: 'road'}, version: 1}),
+            iD.osmWay({id: 'track', tags: {highway: 'track'}, version: 1}),
 
             // Paths
-            iD.Way({id: 'path', tags: {highway: 'path'}, version: 1}),
-            iD.Way({id: 'footway', tags: {highway: 'footway'}, version: 1}),
-            iD.Way({id: 'cycleway', tags: {highway: 'cycleway'}, version: 1}),
-            iD.Way({id: 'bridleway', tags: {highway: 'bridleway'}, version: 1}),
-            iD.Way({id: 'steps', tags: {highway: 'steps'}, version: 1}),
-            iD.Way({id: 'pedestrian', tags: {highway: 'pedestrian'}, version: 1}),
-            iD.Way({id: 'corridor', tags: {highway: 'corridor'}, version: 1}),
+            iD.osmWay({id: 'path', tags: {highway: 'path'}, version: 1}),
+            iD.osmWay({id: 'footway', tags: {highway: 'footway'}, version: 1}),
+            iD.osmWay({id: 'cycleway', tags: {highway: 'cycleway'}, version: 1}),
+            iD.osmWay({id: 'bridleway', tags: {highway: 'bridleway'}, version: 1}),
+            iD.osmWay({id: 'steps', tags: {highway: 'steps'}, version: 1}),
+            iD.osmWay({id: 'pedestrian', tags: {highway: 'pedestrian'}, version: 1}),
+            iD.osmWay({id: 'corridor', tags: {highway: 'corridor'}, version: 1}),
 
             // Buildings
-            iD.Way({id: 'building_yes', tags: {area: 'yes', amenity: 'school', building: 'yes'}, version: 1}),
-            iD.Way({id: 'building_no', tags: {area: 'yes', amenity: 'school', building: 'no'}, version: 1}),
-            iD.Way({id: 'building_part', tags: { 'building:part': 'yes'}, version: 1}),
-            iD.Way({id: 'garage1', tags: {area: 'yes', amenity: 'parking', parking: 'multi-storey'}, version: 1}),
-            iD.Way({id: 'garage2', tags: {area: 'yes', amenity: 'parking', parking: 'sheds'}, version: 1}),
-            iD.Way({id: 'garage3', tags: {area: 'yes', amenity: 'parking', parking: 'carports'}, version: 1}),
-            iD.Way({id: 'garage4', tags: {area: 'yes', amenity: 'parking', parking: 'garage_boxes'}, version: 1}),
+            iD.osmWay({id: 'building_yes', tags: {area: 'yes', amenity: 'school', building: 'yes'}, version: 1}),
+            iD.osmWay({id: 'building_no', tags: {area: 'yes', amenity: 'school', building: 'no'}, version: 1}),
+            iD.osmWay({id: 'building_part', tags: { 'building:part': 'yes'}, version: 1}),
+            iD.osmWay({id: 'garage1', tags: {area: 'yes', amenity: 'parking', parking: 'multi-storey'}, version: 1}),
+            iD.osmWay({id: 'garage2', tags: {area: 'yes', amenity: 'parking', parking: 'sheds'}, version: 1}),
+            iD.osmWay({id: 'garage3', tags: {area: 'yes', amenity: 'parking', parking: 'carports'}, version: 1}),
+            iD.osmWay({id: 'garage4', tags: {area: 'yes', amenity: 'parking', parking: 'garage_boxes'}, version: 1}),
 
             // Landuse
-            iD.Way({id: 'forest', tags: {area: 'yes', landuse: 'forest'}, version: 1}),
-            iD.Way({id: 'scrub', tags: {area: 'yes', natural: 'scrub'}, version: 1}),
-            iD.Way({id: 'industrial', tags: {area: 'yes', landuse: 'industrial'}, version: 1}),
-            iD.Way({id: 'parkinglot', tags: {area: 'yes', amenity: 'parking', parking: 'surface'}, version: 1}),
+            iD.osmWay({id: 'forest', tags: {area: 'yes', landuse: 'forest'}, version: 1}),
+            iD.osmWay({id: 'scrub', tags: {area: 'yes', natural: 'scrub'}, version: 1}),
+            iD.osmWay({id: 'industrial', tags: {area: 'yes', landuse: 'industrial'}, version: 1}),
+            iD.osmWay({id: 'parkinglot', tags: {area: 'yes', amenity: 'parking', parking: 'surface'}, version: 1}),
 
             // Landuse Multipolygon
-            iD.Way({id: 'outer', version: 1}),
-            iD.Way({id: 'inner1', version: 1}),
-            iD.Way({id: 'inner2', tags: {barrier: 'fence'}, version: 1}),
-            iD.Way({id: 'inner3', tags: {highway: 'residential'}, version: 1}),
-            iD.Relation({id: 'retail', tags: {landuse: 'retail', type: 'multipolygon'},
+            iD.osmWay({id: 'outer', version: 1}),
+            iD.osmWay({id: 'inner1', version: 1}),
+            iD.osmWay({id: 'inner2', tags: {barrier: 'fence'}, version: 1}),
+            iD.osmWay({id: 'inner3', tags: {highway: 'residential'}, version: 1}),
+            iD.osmRelation({id: 'retail', tags: {landuse: 'retail', type: 'multipolygon'},
                     members: [
                         {id: 'outer', role: 'outer', type: 'way'},
                         {id: 'inner1', role: 'inner', type: 'way'},
@@ -164,40 +164,40 @@ describe('iD.Features', function() {
                 }),
 
             // Boundaries
-            iD.Way({id: 'boundary', tags: {boundary: 'administrative'}, version: 1}),
-            iD.Way({id: 'boundary_road', tags: {boundary: 'administrative', highway: 'primary'}, version: 1}),
+            iD.osmWay({id: 'boundary', tags: {boundary: 'administrative'}, version: 1}),
+            iD.osmWay({id: 'boundary_road', tags: {boundary: 'administrative', highway: 'primary'}, version: 1}),
 
             // Water
-            iD.Way({id: 'water', tags: {area: 'yes', natural: 'water'}, version: 1}),
-            iD.Way({id: 'coastline', tags: {natural: 'coastline'}, version: 1}),
-            iD.Way({id: 'bay', tags: {area: 'yes', natural: 'bay'}, version: 1}),
-            iD.Way({id: 'pond', tags: {area: 'yes', landuse: 'pond'}, version: 1}),
-            iD.Way({id: 'basin', tags: {area: 'yes', landuse: 'basin'}, version: 1}),
-            iD.Way({id: 'reservoir', tags: {area: 'yes', landuse: 'reservoir'}, version: 1}),
-            iD.Way({id: 'salt_pond', tags: {area: 'yes', landuse: 'salt_pond'}, version: 1}),
-            iD.Way({id: 'river', tags: {waterway: 'river'}, version: 1}),
+            iD.osmWay({id: 'water', tags: {area: 'yes', natural: 'water'}, version: 1}),
+            iD.osmWay({id: 'coastline', tags: {natural: 'coastline'}, version: 1}),
+            iD.osmWay({id: 'bay', tags: {area: 'yes', natural: 'bay'}, version: 1}),
+            iD.osmWay({id: 'pond', tags: {area: 'yes', landuse: 'pond'}, version: 1}),
+            iD.osmWay({id: 'basin', tags: {area: 'yes', landuse: 'basin'}, version: 1}),
+            iD.osmWay({id: 'reservoir', tags: {area: 'yes', landuse: 'reservoir'}, version: 1}),
+            iD.osmWay({id: 'salt_pond', tags: {area: 'yes', landuse: 'salt_pond'}, version: 1}),
+            iD.osmWay({id: 'river', tags: {waterway: 'river'}, version: 1}),
 
             // Rail
-            iD.Way({id: 'railway', tags: {railway: 'rail'}, version: 1}),
-            iD.Way({id: 'rail_landuse', tags: {area: 'yes', landuse: 'railway'}, version: 1}),
-            iD.Way({id: 'rail_disused', tags: {railway: 'disused'}, version: 1}),
-            iD.Way({id: 'rail_streetcar', tags: {railway: 'tram', highway: 'residential'}, version: 1}),
-            iD.Way({id: 'rail_trail', tags: {railway: 'disused', highway: 'cycleway'}, version: 1}),
+            iD.osmWay({id: 'railway', tags: {railway: 'rail'}, version: 1}),
+            iD.osmWay({id: 'rail_landuse', tags: {area: 'yes', landuse: 'railway'}, version: 1}),
+            iD.osmWay({id: 'rail_disused', tags: {railway: 'disused'}, version: 1}),
+            iD.osmWay({id: 'rail_streetcar', tags: {railway: 'tram', highway: 'residential'}, version: 1}),
+            iD.osmWay({id: 'rail_trail', tags: {railway: 'disused', highway: 'cycleway'}, version: 1}),
 
             // Power
-            iD.Way({id: 'power_line', tags: {power: 'line'}, version: 1}),
+            iD.osmWay({id: 'power_line', tags: {power: 'line'}, version: 1}),
 
             // Past/Future
-            iD.Way({id: 'motorway_construction', tags: {highway: 'construction', construction: 'motorway'}, version: 1}),
-            iD.Way({id: 'cycleway_proposed', tags: {highway: 'proposed', proposed: 'cycleway'}, version: 1}),
-            iD.Way({id: 'landuse_construction', tags: {area: 'yes', landuse: 'construction'}, version: 1}),
+            iD.osmWay({id: 'motorway_construction', tags: {highway: 'construction', construction: 'motorway'}, version: 1}),
+            iD.osmWay({id: 'cycleway_proposed', tags: {highway: 'proposed', proposed: 'cycleway'}, version: 1}),
+            iD.osmWay({id: 'landuse_construction', tags: {area: 'yes', landuse: 'construction'}, version: 1}),
 
             // Others
-            iD.Way({id: 'fence', tags: {barrier: 'fence'}, version: 1}),
-            iD.Way({id: 'pipeline', tags: {man_made: 'pipeline'}, version: 1}),
+            iD.osmWay({id: 'fence', tags: {barrier: 'fence'}, version: 1}),
+            iD.osmWay({id: 'pipeline', tags: {man_made: 'pipeline'}, version: 1}),
 
             // Site relation
-            iD.Relation({id: 'site', tags: {type: 'site'},
+            iD.osmRelation({id: 'site', tags: {type: 'site'},
                     members: [
                         {id: 'fence', role: 'perimeter'},
                         {id: 'building_yes'}
@@ -435,10 +435,10 @@ describe('iD.Features', function() {
 
     describe('hiding', function() {
         it('hides child vertices on a hidden way', function() {
-            var a = iD.Node({id: 'a', version: 1}),
-                b = iD.Node({id: 'b', version: 1}),
-                w = iD.Way({id: 'w', nodes: [a.id, b.id], tags: {highway: 'path'}, version: 1}),
-                graph = iD.Graph([a, b, w]),
+            var a = iD.osmNode({id: 'a', version: 1}),
+                b = iD.osmNode({id: 'b', version: 1}),
+                w = iD.osmWay({id: 'w', nodes: [a.id, b.id], tags: {highway: 'path'}, version: 1}),
+                graph = iD.coreGraph([a, b, w]),
                 geometry = a.geometry(graph),
                 all = _values(graph.base().entities);
 
@@ -452,11 +452,11 @@ describe('iD.Features', function() {
         });
 
         it('hides uninteresting (e.g. untagged or "other") member ways on a hidden multipolygon relation', function() {
-            var outer = iD.Way({id: 'outer', tags: {area: 'yes', natural: 'wood'}, version: 1}),
-                inner1 = iD.Way({id: 'inner1', tags: {barrier: 'fence'}, version: 1}),
-                inner2 = iD.Way({id: 'inner2', version: 1}),
-                inner3 = iD.Way({id: 'inner3', tags: {highway: 'residential'}, version: 1}),
-                r = iD.Relation({
+            var outer = iD.osmWay({id: 'outer', tags: {area: 'yes', natural: 'wood'}, version: 1}),
+                inner1 = iD.osmWay({id: 'inner1', tags: {barrier: 'fence'}, version: 1}),
+                inner2 = iD.osmWay({id: 'inner2', version: 1}),
+                inner3 = iD.osmWay({id: 'inner3', tags: {highway: 'residential'}, version: 1}),
+                r = iD.osmRelation({
                     id: 'r',
                     tags: {type: 'multipolygon'},
                     members: [
@@ -467,7 +467,7 @@ describe('iD.Features', function() {
                     ],
                     version: 1
                 }),
-                graph = iD.Graph([outer, inner1, inner2, inner3, r]),
+                graph = iD.coreGraph([outer, inner1, inner2, inner3, r]),
                 all = _values(graph.base().entities);
 
             features.disable('landuse');
@@ -480,9 +480,9 @@ describe('iD.Features', function() {
         });
 
         it('hides only versioned entities', function() {
-            var a = iD.Node({id: 'a', version: 1}),
-                b = iD.Node({id: 'b'}),
-                graph = iD.Graph([a, b]),
+            var a = iD.osmNode({id: 'a', version: 1}),
+                b = iD.osmNode({id: 'b'}),
+                graph = iD.coreGraph([a, b]),
                 ageo = a.geometry(graph),
                 bgeo = b.geometry(graph),
                 all = _values(graph.base().entities);
@@ -495,12 +495,12 @@ describe('iD.Features', function() {
         });
 
         it('auto-hides features', function() {
-            var graph = iD.Graph([]),
+            var graph = iD.coreGraph([]),
                 maxPoints = 200,
                 all, hidden, autoHidden, i, msg;
 
             for (i = 0; i < maxPoints; i++) {
-                graph.rebase([iD.Node({version: 1})], [graph]);
+                graph.rebase([iD.osmNode({version: 1})], [graph]);
             }
 
             all = _values(graph.base().entities);
@@ -512,7 +512,7 @@ describe('iD.Features', function() {
             expect(hidden, msg).to.not.include('points');
             expect(autoHidden, msg).to.not.include('points');
 
-            graph.rebase([iD.Node({version: 1})], [graph]);
+            graph.rebase([iD.osmNode({version: 1})], [graph]);
 
             all = _values(graph.base().entities);
             features.gatherStats(all, graph, dimensions);
@@ -525,13 +525,13 @@ describe('iD.Features', function() {
         });
 
         it('doubles auto-hide threshold when doubling viewport size', function() {
-            var graph = iD.Graph([]),
+            var graph = iD.coreGraph([]),
                 maxPoints = 400,
                 dimensions = [2000, 1000],
                 all, hidden, autoHidden, i, msg;
 
             for (i = 0; i < maxPoints; i++) {
-                graph.rebase([iD.Node({version: 1})], [graph]);
+                graph.rebase([iD.osmNode({version: 1})], [graph]);
             }
 
             all = _values(graph.base().entities);
@@ -543,7 +543,7 @@ describe('iD.Features', function() {
             expect(hidden, msg).to.not.include('points');
             expect(autoHidden, msg).to.not.include('points');
 
-            graph.rebase([iD.Node({version: 1})], [graph]);
+            graph.rebase([iD.osmNode({version: 1})], [graph]);
 
             all = _values(graph.base().entities);
             features.gatherStats(all, graph, dimensions);
diff --git a/test/spec/renderer/map.js b/test/spec/renderer/map.js
index 366eb95d4..ccb1dee2e 100644
--- a/test/spec/renderer/map.js
+++ b/test/spec/renderer/map.js
@@ -3,7 +3,7 @@ describe('iD.Map', function() {
 
     beforeEach(function() {
         content = d3.select('body').append('div');
-        context = iD.Context();
+        context = iD.coreContext();
         map = context.map();
         content.call(map);
     });
diff --git a/test/spec/renderer/tile_layer.js b/test/spec/renderer/tile_layer.js
index 6d940a86a..750df1d60 100644
--- a/test/spec/renderer/tile_layer.js
+++ b/test/spec/renderer/tile_layer.js
@@ -2,7 +2,7 @@ describe('iD.TileLayer', function() {
     var context, d, c;
 
     beforeEach(function() {
-        context = iD.Context();
+        context = iD.coreContext();
         d = d3.select(document.createElement('div'));
         c = iD.TileLayer(context).projection(d3.geoMercator());
     });
diff --git a/test/spec/services/mapillary.js b/test/spec/services/mapillary.js
index 6e9667a0b..f1ca87dc4 100644
--- a/test/spec/services/mapillary.js
+++ b/test/spec/services/mapillary.js
@@ -12,7 +12,7 @@ describe('iD.serviceMapillary', function() {
     });
 
     beforeEach(function() {
-        context = iD.Context().assetPath('../dist/');
+        context = iD.coreContext().assetPath('../dist/');
         context.projection
             .scale(667544.214430109)  // z14
             .translate([-116508, 0])  // 10,0
diff --git a/test/spec/services/openstreetcam.js b/test/spec/services/openstreetcam.js
index 67bbadf0d..a3f512986 100644
--- a/test/spec/services/openstreetcam.js
+++ b/test/spec/services/openstreetcam.js
@@ -11,7 +11,7 @@ describe('iD.serviceOpenstreetcam', function() {
     });
 
     beforeEach(function() {
-        context = iD.Context().assetPath('../dist/');
+        context = iD.coreContext().assetPath('../dist/');
         context.projection
             .scale(667544.214430109)  // z14
             .translate([-116508, 0])  // 10,0
diff --git a/test/spec/services/osm.js b/test/spec/services/osm.js
index c977cf599..0bc95d8f3 100644
--- a/test/spec/services/osm.js
+++ b/test/spec/services/osm.js
@@ -27,7 +27,7 @@ describe('iD.serviceOsm', function () {
 
     beforeEach(function () {
         server = sinon.fakeServer.create();
-        context = iD.Context();
+        context = iD.coreContext();
         connection = context.connection();
         connection.switch({ urlroot: 'http://www.openstreetmap.org' });
         connection.reset();
@@ -83,30 +83,30 @@ describe('iD.serviceOsm', function () {
 
     describe('#entityURL', function() {
         it('provides an entity url for a node', function() {
-            var e = iD.Node({id: 'n1'});
+            var e = iD.osmNode({id: 'n1'});
             expect(connection.entityURL(e)).to.eql('http://www.openstreetmap.org/node/1');
         });
         it('provides an entity url for a way', function() {
-            var e = iD.Way({id: 'w1'});
+            var e = iD.osmWay({id: 'w1'});
             expect(connection.entityURL(e)).to.eql('http://www.openstreetmap.org/way/1');
         });
         it('provides an entity url for a relation', function() {
-            var e = iD.Relation({id: 'r1'});
+            var e = iD.osmRelation({id: 'r1'});
             expect(connection.entityURL(e)).to.eql('http://www.openstreetmap.org/relation/1');
         });
     });
 
     describe('#historyURL', function() {
         it('provides a history url for a node', function() {
-            var e = iD.Node({id: 'n1'});
+            var e = iD.osmNode({id: 'n1'});
             expect(connection.historyURL(e)).to.eql('http://www.openstreetmap.org/node/1/history');
         });
         it('provides a history url for a way', function() {
-            var e = iD.Way({id: 'w1'});
+            var e = iD.osmWay({id: 'w1'});
             expect(connection.historyURL(e)).to.eql('http://www.openstreetmap.org/way/1/history');
         });
         it('provides a history url for a relation', function() {
-            var e = iD.Relation({id: 'r1'});
+            var e = iD.osmRelation({id: 'r1'});
             expect(connection.historyURL(e)).to.eql('http://www.openstreetmap.org/relation/1/history');
         });
     });
@@ -314,7 +314,7 @@ describe('iD.serviceOsm', function () {
             var id = 'n1';
             connection.loadEntity(id, function(err, result) {
                 var entity = result.data.find(function(e) { return e.id === id; });
-                expect(entity).to.be.an.instanceOf(iD.Node);
+                expect(entity).to.be.an.instanceOf(iD.osmNode);
                 done();
             });
 
@@ -327,7 +327,7 @@ describe('iD.serviceOsm', function () {
             var id = 'w1';
             connection.loadEntity(id, function(err, result) {
                 var entity = result.data.find(function(e) { return e.id === id; });
-                expect(entity).to.be.an.instanceOf(iD.Way);
+                expect(entity).to.be.an.instanceOf(iD.osmWay);
                 done();
             });
 
@@ -340,10 +340,10 @@ describe('iD.serviceOsm', function () {
             var id = 'n1';
             connection.loadEntity(id, function(err1, result1) {
                 var entity1 = result1.data.find(function(e1) { return e1.id === id; });
-                expect(entity1).to.be.an.instanceOf(iD.Node);
+                expect(entity1).to.be.an.instanceOf(iD.osmNode);
                 connection.loadEntity(id, function(err2, result2) {
                     var entity2 = result2.data.find(function(e2) { return e2.id === id; });
-                    expect(entity2).to.be.an.instanceOf(iD.Node);
+                    expect(entity2).to.be.an.instanceOf(iD.osmNode);
                     done();
                 });
                 server.respond();
@@ -376,7 +376,7 @@ describe('iD.serviceOsm', function () {
             var id = 'n1';
             connection.loadEntityVersion(id, 1, function(err, result) {
                 var entity = result.data.find(function(e) { return e.id === id; });
-                expect(entity).to.be.an.instanceOf(iD.Node);
+                expect(entity).to.be.an.instanceOf(iD.osmNode);
                 done();
             });
 
@@ -389,7 +389,7 @@ describe('iD.serviceOsm', function () {
             var id = 'w1';
             connection.loadEntityVersion(id, 1, function(err, result) {
                 var entity = result.data.find(function(e) { return e.id === id; });
-                expect(entity).to.be.an.instanceOf(iD.Way);
+                expect(entity).to.be.an.instanceOf(iD.osmWay);
                 done();
             });
 
@@ -402,10 +402,10 @@ describe('iD.serviceOsm', function () {
             var id = 'n1';
             connection.loadEntityVersion(id, 1, function(err1, result1) {
                 var entity1 = result1.data.find(function(e1) { return e1.id === id; });
-                expect(entity1).to.be.an.instanceOf(iD.Node);
+                expect(entity1).to.be.an.instanceOf(iD.osmNode);
                 connection.loadEntityVersion(id, 1, function(err2, result2) {
                     var entity2 = result2.data.find(function(e2) { return e2.id === id; });
-                    expect(entity2).to.be.an.instanceOf(iD.Node);
+                    expect(entity2).to.be.an.instanceOf(iD.osmNode);
                     done();
                 });
                 server.respond();
diff --git a/test/spec/services/streetside.js b/test/spec/services/streetside.js
index f0ebebe79..b8adb2f1c 100644
--- a/test/spec/services/streetside.js
+++ b/test/spec/services/streetside.js
@@ -11,7 +11,7 @@ describe('iD.serviceStreetside', function() {
     });
 
     beforeEach(function() {
-        context = iD.Context().assetPath('../dist/');
+        context = iD.coreContext().assetPath('../dist/');
         context.projection
             .scale(667544.214430109)  // z14
             .translate([-116508, 0])  // 10,0
diff --git a/test/spec/svg/svg.js b/test/spec/svg/svg.js
index 05045871c..16152493a 100644
--- a/test/spec/svg/svg.js
+++ b/test/spec/svg/svg.js
@@ -1,8 +1,8 @@
 describe('iD.svgRelationMemberTags', function() {
     it('includes tags from parent multipolygon relations', function() {
-        var graph = iD.Graph([
-            iD.Way({id: 'w'}),
-            iD.Relation({id: 'r', members: [{id: 'w'}], tags: {type: 'multipolygon'}})
+        var graph = iD.coreGraph([
+            iD.osmWay({id: 'w'}),
+            iD.osmRelation({id: 'r', members: [{id: 'w'}], tags: {type: 'multipolygon'}})
         ]);
 
         expect(iD.svgRelationMemberTags(graph)(graph.entity('w')))
@@ -10,9 +10,9 @@ describe('iD.svgRelationMemberTags', function() {
     });
 
     it('includes tags from parent boundary relations', function() {
-        var graph = iD.Graph([
-            iD.Way({id: 'w'}),
-            iD.Relation({id: 'r', members: [{id: 'w'}], tags: {type: 'boundary'}})
+        var graph = iD.coreGraph([
+            iD.osmWay({id: 'w'}),
+            iD.osmRelation({id: 'r', members: [{id: 'w'}], tags: {type: 'boundary'}})
         ]);
 
         expect(iD.svgRelationMemberTags(graph)(graph.entity('w')))
diff --git a/test/spec/ui/fields/access.js b/test/spec/ui/fields/access.js
index 969f808e7..45b84eb10 100644
--- a/test/spec/ui/fields/access.js
+++ b/test/spec/ui/fields/access.js
@@ -2,7 +2,7 @@ describe('iD.uiFieldAccess', function() {
     var context, selection, field;
 
     beforeEach(function() {
-        context = iD.Context();
+        context = iD.coreContext();
         selection = d3.select(document.createElement('div'));
         field = context.presets().field('access');
     });
diff --git a/test/spec/ui/fields/localized.js b/test/spec/ui/fields/localized.js
index 8dc6ed8dc..e0736cf43 100644
--- a/test/spec/ui/fields/localized.js
+++ b/test/spec/ui/fields/localized.js
@@ -2,7 +2,7 @@ describe('iD.uiFieldLocalized', function() {
     var context, selection, field;
 
     beforeEach(function() {
-        context = iD.Context();
+        context = iD.coreContext();
         selection = d3.select(document.createElement('div'));
         field = iD.presetField('test', {key: 'name'});
     });
diff --git a/test/spec/ui/fields/wikipedia.js b/test/spec/ui/fields/wikipedia.js
index a1a804bc1..6f7983545 100644
--- a/test/spec/ui/fields/wikipedia.js
+++ b/test/spec/ui/fields/wikipedia.js
@@ -43,8 +43,8 @@ describe('iD.uiFieldWikipedia', function() {
     });
 
     beforeEach(function() {
-        entity = iD.Node({id: 'n12345'});
-        context = iD.Context();
+        entity = iD.osmNode({id: 'n12345'});
+        context = iD.coreContext();
         context.history().merge([entity]);
         selection = d3.select(document.createElement('div'));
         field = context.presets().field('wikipedia');
diff --git a/test/spec/ui/raw_tag_editor.js b/test/spec/ui/raw_tag_editor.js
index a6ec85bee..c48116719 100644
--- a/test/spec/ui/raw_tag_editor.js
+++ b/test/spec/ui/raw_tag_editor.js
@@ -15,8 +15,8 @@ describe('iD.uiRawTagEditor', function() {
     }
 
     beforeEach(function () {
-        entity = iD.Node({id: 'n12345'});
-        context = iD.Context();
+        entity = iD.osmNode({id: 'n12345'});
+        context = iD.coreContext();
         context.history().merge([entity]);
         render({highway: 'residential'});
     });
diff --git a/test/spec/util/util.js b/test/spec/util/util.js
index da64f309e..bd7a8b2ef 100644
--- a/test/spec/util/util.js
+++ b/test/spec/util/util.js
@@ -2,10 +2,10 @@ describe('iD.util', function() {
 
     describe('utilGetAllNodes', function() {
         it('gets all descendant nodes of a way', function() {
-            var a = iD.Node({ id: 'a' }),
-                b = iD.Node({ id: 'b' }),
-                w = iD.Way({ id: 'w', nodes: ['a','b','a'] }),
-                graph = iD.Graph([a, b, w]),
+            var a = iD.osmNode({ id: 'a' }),
+                b = iD.osmNode({ id: 'b' }),
+                w = iD.osmWay({ id: 'w', nodes: ['a','b','a'] }),
+                graph = iD.coreGraph([a, b, w]),
                 result = iD.utilGetAllNodes(['w'], graph);
 
             expect(result).to.have.members([a, b]);
@@ -13,12 +13,12 @@ describe('iD.util', function() {
         });
 
         it('gets all descendant nodes of a relation', function() {
-            var a = iD.Node({ id: 'a' }),
-                b = iD.Node({ id: 'b' }),
-                c = iD.Node({ id: 'c' }),
-                w = iD.Way({ id: 'w', nodes: ['a','b','a'] }),
-                r = iD.Relation({ id: 'r', members: [{id: 'w'}, {id: 'c'}] }),
-                graph = iD.Graph([a, b, c, w, r]),
+            var a = iD.osmNode({ id: 'a' }),
+                b = iD.osmNode({ id: 'b' }),
+                c = iD.osmNode({ id: 'c' }),
+                w = iD.osmWay({ id: 'w', nodes: ['a','b','a'] }),
+                r = iD.osmRelation({ id: 'r', members: [{id: 'w'}, {id: 'c'}] }),
+                graph = iD.coreGraph([a, b, c, w, r]),
                 result = iD.utilGetAllNodes(['r'], graph);
 
             expect(result).to.have.members([a, b, c]);
@@ -26,15 +26,15 @@ describe('iD.util', function() {
         });
 
         it('gets all descendant nodes of multiple ids', function() {
-            var a = iD.Node({ id: 'a' }),
-                b = iD.Node({ id: 'b' }),
-                c = iD.Node({ id: 'c' }),
-                d = iD.Node({ id: 'd' }),
-                e = iD.Node({ id: 'e' }),
-                w1 = iD.Way({ id: 'w1', nodes: ['a','b','a'] }),
-                w2 = iD.Way({ id: 'w2', nodes: ['c','b','a','c'] }),
-                r = iD.Relation({ id: 'r', members: [{id: 'w1'}, {id: 'd'}] }),
-                graph = iD.Graph([a, b, c, d, e, w1, w2, r]),
+            var a = iD.osmNode({ id: 'a' }),
+                b = iD.osmNode({ id: 'b' }),
+                c = iD.osmNode({ id: 'c' }),
+                d = iD.osmNode({ id: 'd' }),
+                e = iD.osmNode({ id: 'e' }),
+                w1 = iD.osmWay({ id: 'w1', nodes: ['a','b','a'] }),
+                w2 = iD.osmWay({ id: 'w2', nodes: ['c','b','a','c'] }),
+                r = iD.osmRelation({ id: 'r', members: [{id: 'w1'}, {id: 'd'}] }),
+                graph = iD.coreGraph([a, b, c, d, e, w1, w2, r]),
                 result = iD.utilGetAllNodes(['r', 'w2', 'e'], graph);
 
             expect(result).to.have.members([a, b, c, d, e]);
@@ -42,10 +42,10 @@ describe('iD.util', function() {
         });
 
         it('handles recursive relations', function() {
-            var a = iD.Node({ id: 'a' }),
-                r1 = iD.Relation({ id: 'r1', members: [{id: 'r2'}] }),
-                r2 = iD.Relation({ id: 'r2', members: [{id: 'r1'}, {id: 'a'}] }),
-                graph = iD.Graph([a, r1, r2]),
+            var a = iD.osmNode({ id: 'a' }),
+                r1 = iD.osmRelation({ id: 'r1', members: [{id: 'r2'}] }),
+                r2 = iD.osmRelation({ id: 'r2', members: [{id: 'r1'}, {id: 'a'}] }),
+                graph = iD.coreGraph([a, r1, r2]),
                 result = iD.utilGetAllNodes(['r1'], graph);
 
             expect(result).to.have.members([a]);