Rename Instances<T> to Table<T> and the "instance" terminology to "TableRow" and "element" (#2981)

* Instances -> Table

* instances.rs -> table.rs

* Rename occurrances of the word "instances"

* .instance -> .element

* Instance* -> TableRow*

* Rename Table and TableRow methods to not say "instance"

* Remove presumed unused serde defaults now that tables default to length 0 not 1

* Rename occurences of the word "instance"

* Un-alias the RasterDataTable<Storage>, VectorDataTable, GraphicGroupTable, ArtboardGroupTable typedefs

* Move artboard type and node code out of graphic_element.rs to a new artboard.rs

* Organize the TaggedValues

* Fix tests

* Fix prior regression with Image Value node not upgrading

editor/src/messages/portfolio/document/document_message.rs

@@ -182,7 +182,7 @@ pub enum DocumentMessage {
 	UpdateUpstreamTransforms {
 		upstream_footprints: HashMap<NodeId, Footprint>,
 		local_transforms: HashMap<NodeId, DAffine2>,
-		first_instance_source_id: HashMap<NodeId, Option<NodeId>>,
+		first_element_source_id: HashMap<NodeId, Option<NodeId>>,
 	},
 	UpdateClickTargets {
 		click_targets: HashMap<NodeId, Vec<ClickTarget>>,

editor/src/messages/portfolio/document/document_message_handler.rs

@@ -32,7 +32,8 @@ use graph_craft::document::{NodeId, NodeInput, NodeNetwork, OldNodeNetwork};
 use graphene_std::math::quad::Quad;
 use graphene_std::path_bool::{boolean_intersect, path_bool_lib};
 use graphene_std::raster::BlendMode;
-use graphene_std::raster_types::{Raster, RasterDataTable};
+use graphene_std::raster_types::Raster;
+use graphene_std::table::Table;
 use graphene_std::vector::PointId;
 use graphene_std::vector::click_target::{ClickTarget, ClickTargetType};
 use graphene_std::vector::style::ViewMode;
@@ -837,7 +838,7 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 
 				responses.add(DocumentMessage::AddTransaction);
 
-				let layer = graph_modification_utils::new_image_layer(RasterDataTable::new(Raster::new_cpu(image)), layer_node_id, self.new_layer_parent(true), responses);
+				let layer = graph_modification_utils::new_image_layer(Table::new_from_element(Raster::new_cpu(image)), layer_node_id, self.new_layer_parent(true), responses);
 
 				if let Some(name) = name {
 					responses.add(NodeGraphMessage::SetDisplayName {
@@ -1302,10 +1303,10 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 			DocumentMessage::UpdateUpstreamTransforms {
 				upstream_footprints,
 				local_transforms,
-				first_instance_source_id,
+				first_element_source_id,
 			} => {
 				self.network_interface.update_transforms(upstream_footprints, local_transforms);
-				self.network_interface.update_first_instance_source_id(first_instance_source_id);
+				self.network_interface.update_first_element_source_id(first_element_source_id);
 			}
 			DocumentMessage::UpdateClickTargets { click_targets } => {
 				// TODO: Allow non layer nodes to have click targets
@@ -2920,7 +2921,7 @@ impl DocumentMessageHandler {
 /// Create a network interface with a single export
 fn default_document_network_interface() -> NodeNetworkInterface {
 	let mut network_interface = NodeNetworkInterface::default();
-	network_interface.add_export(TaggedValue::ArtboardGroup(graphene_std::ArtboardGroupTable::default()), -1, "", &[]);
+	network_interface.add_export(TaggedValue::ArtboardGroup(Default::default()), -1, "", &[]);
 	network_interface
 }
 

editor/src/messages/portfolio/document/graph_operation/graph_operation_message.rs

@@ -8,7 +8,8 @@ use graph_craft::document::NodeId;
 use graphene_std::Artboard;
 use graphene_std::brush::brush_stroke::BrushStroke;
 use graphene_std::raster::BlendMode;
-use graphene_std::raster_types::{CPU, RasterDataTable};
+use graphene_std::raster_types::{CPU, Raster};
+use graphene_std::table::Table;
 use graphene_std::text::{Font, TypesettingConfig};
 use graphene_std::vector::PointId;
 use graphene_std::vector::VectorModificationType;
@@ -69,7 +70,7 @@ pub enum GraphOperationMessage {
 	},
 	NewBitmapLayer {
 		id: NodeId,
-		image_frame: RasterDataTable<CPU>,
+		image_frame: Table<Raster<CPU>>,
 		parent: LayerNodeIdentifier,
 		insert_index: usize,
 	},

editor/src/messages/portfolio/document/graph_operation/utility_types.rs

@@ -11,12 +11,13 @@ use graph_craft::document::{NodeId, NodeInput};
 use graphene_std::Artboard;
 use graphene_std::brush::brush_stroke::BrushStroke;
 use graphene_std::raster::BlendMode;
-use graphene_std::raster_types::{CPU, RasterDataTable};
+use graphene_std::raster_types::{CPU, Raster};
+use graphene_std::table::Table;
 use graphene_std::text::{Font, TypesettingConfig};
+use graphene_std::vector::VectorData;
 use graphene_std::vector::style::{Fill, Stroke};
 use graphene_std::vector::{PointId, VectorModificationType};
-use graphene_std::vector::{VectorData, VectorDataTable};
-use graphene_std::{GraphicGroupTable, NodeInputDecleration};
+use graphene_std::{GraphicElement, NodeInputDecleration};
 
 #[derive(PartialEq, Clone, Copy, Debug, serde::Serialize, serde::Deserialize)]
 pub enum TransformIn {
@@ -130,8 +131,8 @@ impl<'a> ModifyInputsContext<'a> {
 	/// Creates an artboard as the primary export for the document network
 	pub fn create_artboard(&mut self, new_id: NodeId, artboard: Artboard) -> LayerNodeIdentifier {
 		let artboard_node_template = resolve_document_node_type("Artboard").expect("Node").node_template_input_override([
-			Some(NodeInput::value(TaggedValue::ArtboardGroup(graphene_std::ArtboardGroupTable::default()), true)),
-			Some(NodeInput::value(TaggedValue::GraphicGroup(graphene_std::GraphicGroupTable::default()), true)),
+			Some(NodeInput::value(TaggedValue::ArtboardGroup(Default::default()), true)),
+			Some(NodeInput::value(TaggedValue::GraphicGroup(Default::default()), true)),
 			Some(NodeInput::value(TaggedValue::DVec2(artboard.location.into()), false)),
 			Some(NodeInput::value(TaggedValue::DVec2(artboard.dimensions.into()), false)),
 			Some(NodeInput::value(TaggedValue::Color(artboard.background), false)),
@@ -143,7 +144,7 @@ impl<'a> ModifyInputsContext<'a> {
 
 	pub fn insert_boolean_data(&mut self, operation: graphene_std::path_bool::BooleanOperation, layer: LayerNodeIdentifier) {
 		let boolean = resolve_document_node_type("Boolean Operation").expect("Boolean node does not exist").node_template_input_override([
-			Some(NodeInput::value(TaggedValue::GraphicGroup(graphene_std::GraphicGroupTable::default()), true)),
+			Some(NodeInput::value(TaggedValue::GraphicGroup(Default::default()), true)),
 			Some(NodeInput::value(TaggedValue::BooleanOperation(operation), false)),
 		]);
 
@@ -153,7 +154,7 @@ impl<'a> ModifyInputsContext<'a> {
 	}
 
 	pub fn insert_vector_data(&mut self, subpaths: Vec<Subpath<PointId>>, layer: LayerNodeIdentifier, include_transform: bool, include_fill: bool, include_stroke: bool) {
-		let vector_data = VectorDataTable::new(VectorData::from_subpaths(subpaths, true));
+		let vector_data = Table::new_from_element(VectorData::from_subpaths(subpaths, true));
 
 		let shape = resolve_document_node_type("Path")
 			.expect("Path node does not exist")
@@ -218,7 +219,7 @@ impl<'a> ModifyInputsContext<'a> {
 		self.network_interface.move_node_to_chain_start(&stroke_id, layer, &[]);
 	}
 
-	pub fn insert_image_data(&mut self, image_frame: RasterDataTable<CPU>, layer: LayerNodeIdentifier) {
+	pub fn insert_image_data(&mut self, image_frame: Table<Raster<CPU>>, layer: LayerNodeIdentifier) {
 		let transform = resolve_document_node_type("Transform").expect("Transform node does not exist").default_node_template();
 		let image = resolve_document_node_type("Image Value")
 			.expect("ImageValue node does not exist")
@@ -302,7 +303,7 @@ impl<'a> ModifyInputsContext<'a> {
 		// TODO: Allow the path node to operate on Graphic Group data by utilizing the reference for each vector data in a group.
 		if node_definition.identifier == "Path" {
 			let layer_input_type = self.network_interface.input_type(&InputConnector::node(output_layer.to_node(), 1), &[]).0.nested_type().clone();
-			if layer_input_type == concrete!(GraphicGroupTable) {
+			if layer_input_type == concrete!(Table<GraphicElement>) {
 				let Some(flatten_path_definition) = resolve_document_node_type("Flatten Path") else {
 					log::error!("Flatten Path does not exist in ModifyInputsContext::existing_node_id");
 					return None;

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -19,11 +19,12 @@ use graph_craft::document::*;
 use graphene_std::brush::brush_cache::BrushCache;
 use graphene_std::extract_xy::XY;
 use graphene_std::raster::{CellularDistanceFunction, CellularReturnType, Color, DomainWarpType, FractalType, NoiseType, RedGreenBlueAlpha};
-use graphene_std::raster_types::{CPU, RasterDataTable};
+use graphene_std::raster_types::{CPU, Raster};
+use graphene_std::table::Table;
 use graphene_std::text::{Font, TypesettingConfig};
 #[allow(unused_imports)]
 use graphene_std::transform::Footprint;
-use graphene_std::vector::VectorDataTable;
+use graphene_std::vector::VectorData;
 use graphene_std::*;
 use std::collections::{HashMap, HashSet, VecDeque};
 
@@ -268,8 +269,8 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						..Default::default()
 					}),
 					inputs: vec![
-						NodeInput::value(TaggedValue::GraphicGroup(GraphicGroupTable::default()), true),
-						NodeInput::value(TaggedValue::GraphicGroup(GraphicGroupTable::default()), true),
+						NodeInput::value(TaggedValue::GraphicGroup(Default::default()), true),
+						NodeInput::value(TaggedValue::GraphicGroup(Default::default()), true),
 					],
 					..Default::default()
 				},
@@ -338,7 +339,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 							// Ensure this ID is kept in sync with the ID in set_alias so that the name input is kept in sync with the alias
 							DocumentNode {
 								manual_composition: Some(generic!(T)),
-								implementation: DocumentNodeImplementation::ProtoNode(graphic_element::to_artboard::IDENTIFIER),
+								implementation: DocumentNodeImplementation::ProtoNode(artboard::to_artboard::IDENTIFIER),
 								inputs: vec![
 									NodeInput::network(concrete!(TaggedValue), 1),
 									NodeInput::value(TaggedValue::String(String::from("Artboard")), false),
@@ -361,11 +362,11 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 							DocumentNode {
 								manual_composition: Some(concrete!(Context)),
 								inputs: vec![
-									NodeInput::network(graphene_std::Type::Fn(Box::new(concrete!(Context)), Box::new(concrete!(ArtboardGroupTable))), 0),
+									NodeInput::network(graphene_std::Type::Fn(Box::new(concrete!(Context)), Box::new(concrete!(Table<Artboard>))), 0),
 									NodeInput::node(NodeId(1), 0),
 									NodeInput::Reflection(graph_craft::document::DocumentNodeMetadata::DocumentNodePath),
 								],
-								implementation: DocumentNodeImplementation::ProtoNode(graphic_element::append_artboard::IDENTIFIER),
+								implementation: DocumentNodeImplementation::ProtoNode(artboard::append_artboard::IDENTIFIER),
 								..Default::default()
 							},
 						]
@@ -376,8 +377,8 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						..Default::default()
 					}),
 					inputs: vec![
-						NodeInput::value(TaggedValue::ArtboardGroup(ArtboardGroupTable::default()), true),
-						NodeInput::value(TaggedValue::GraphicGroup(GraphicGroupTable::default()), true),
+						NodeInput::value(TaggedValue::ArtboardGroup(Default::default()), true),
+						NodeInput::value(TaggedValue::GraphicGroup(Default::default()), true),
 						NodeInput::value(TaggedValue::DVec2(DVec2::ZERO), false),
 						NodeInput::value(TaggedValue::DVec2(DVec2::new(1920., 1080.)), false),
 						NodeInput::value(TaggedValue::Color(Color::WHITE), false),
@@ -627,7 +628,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						..Default::default()
 					}),
 					inputs: vec![
-						NodeInput::value(TaggedValue::VectorData(VectorDataTable::default()), true),
+						NodeInput::value(TaggedValue::VectorData(Default::default()), true),
 						NodeInput::value(
 							TaggedValue::Footprint(Footprint {
 								transform: DAffine2::from_scale_angle_translation(DVec2::new(1000., 1000.), 0., DVec2::new(0., 0.)),
@@ -752,7 +753,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						nodes: [
 							DocumentNode {
 								inputs: vec![
-									NodeInput::network(concrete!(RasterDataTable<CPU>), 0),
+									NodeInput::network(concrete!(Table<Raster<CPU>>), 0),
 									NodeInput::value(TaggedValue::RedGreenBlueAlpha(RedGreenBlueAlpha::Red), false),
 								],
 								implementation: DocumentNodeImplementation::ProtoNode(raster_nodes::adjustments::extract_channel::IDENTIFIER),
@@ -761,7 +762,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 							},
 							DocumentNode {
 								inputs: vec![
-									NodeInput::network(concrete!(RasterDataTable<CPU>), 0),
+									NodeInput::network(concrete!(Table<Raster<CPU>>), 0),
 									NodeInput::value(TaggedValue::RedGreenBlueAlpha(RedGreenBlueAlpha::Green), false),
 								],
 								implementation: DocumentNodeImplementation::ProtoNode(raster_nodes::adjustments::extract_channel::IDENTIFIER),
@@ -770,7 +771,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 							},
 							DocumentNode {
 								inputs: vec![
-									NodeInput::network(concrete!(RasterDataTable<CPU>), 0),
+									NodeInput::network(concrete!(Table<Raster<CPU>>), 0),
 									NodeInput::value(TaggedValue::RedGreenBlueAlpha(RedGreenBlueAlpha::Blue), false),
 								],
 								implementation: DocumentNodeImplementation::ProtoNode(raster_nodes::adjustments::extract_channel::IDENTIFIER),
@@ -779,7 +780,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 							},
 							DocumentNode {
 								inputs: vec![
-									NodeInput::network(concrete!(RasterDataTable<CPU>), 0),
+									NodeInput::network(concrete!(Table<Raster<CPU>>), 0),
 									NodeInput::value(TaggedValue::RedGreenBlueAlpha(RedGreenBlueAlpha::Alpha), false),
 								],
 								implementation: DocumentNodeImplementation::ProtoNode(raster_nodes::adjustments::extract_channel::IDENTIFIER),
@@ -793,7 +794,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						.collect(),
 						..Default::default()
 					}),
-					inputs: vec![NodeInput::value(TaggedValue::RasterData(RasterDataTable::default()), true)],
+					inputs: vec![NodeInput::value(TaggedValue::RasterData(Default::default()), true)],
 					..Default::default()
 				},
 				persistent_node_metadata: DocumentNodePersistentMetadata {
@@ -859,13 +860,13 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						exports: vec![NodeInput::node(NodeId(0), 0), NodeInput::node(NodeId(1), 0)],
 						nodes: [
 							DocumentNode {
-								inputs: vec![NodeInput::network(concrete!(RasterDataTable<CPU>), 0), NodeInput::value(TaggedValue::XY(XY::X), false)],
+								inputs: vec![NodeInput::network(concrete!(Table<Raster<CPU>>), 0), NodeInput::value(TaggedValue::XY(XY::X), false)],
 								implementation: DocumentNodeImplementation::ProtoNode(extract_xy::extract_xy::IDENTIFIER),
 								manual_composition: Some(generic!(T)),
 								..Default::default()
 							},
 							DocumentNode {
-								inputs: vec![NodeInput::network(concrete!(RasterDataTable<CPU>), 0), NodeInput::value(TaggedValue::XY(XY::Y), false)],
+								inputs: vec![NodeInput::network(concrete!(Table<Raster<CPU>>), 0), NodeInput::value(TaggedValue::XY(XY::Y), false)],
 								implementation: DocumentNodeImplementation::ProtoNode(extract_xy::extract_xy::IDENTIFIER),
 								manual_composition: Some(generic!(T)),
 								..Default::default()
@@ -878,7 +879,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 
 						..Default::default()
 					}),
-					inputs: vec![NodeInput::value(TaggedValue::RasterData(RasterDataTable::default()), true)],
+					inputs: vec![NodeInput::value(TaggedValue::RasterData(Default::default()), true)],
 					..Default::default()
 				},
 				persistent_node_metadata: DocumentNodePersistentMetadata {
@@ -931,7 +932,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						exports: vec![NodeInput::node(NodeId(0), 0)],
 						nodes: vec![DocumentNode {
 							inputs: vec![
-								NodeInput::network(concrete!(RasterDataTable<CPU>), 0),
+								NodeInput::network(concrete!(Table<Raster<CPU>>), 0),
 								NodeInput::network(concrete!(Vec<brush::brush_stroke::BrushStroke>), 1),
 								NodeInput::network(concrete!(BrushCache), 2),
 							],
@@ -946,7 +947,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						..Default::default()
 					}),
 					inputs: vec![
-						NodeInput::value(TaggedValue::RasterData(RasterDataTable::default()), true),
+						NodeInput::value(TaggedValue::RasterData(Default::default()), true),
 						NodeInput::value(TaggedValue::BrushStrokes(Vec::new()), false),
 						NodeInput::value(TaggedValue::BrushCache(BrushCache::default()), false),
 					],
@@ -985,7 +986,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			node_template: NodeTemplate {
 				document_node: DocumentNode {
 					implementation: DocumentNodeImplementation::ProtoNode(memo::memo::IDENTIFIER),
-					inputs: vec![NodeInput::value(TaggedValue::RasterData(RasterDataTable::default()), true)],
+					inputs: vec![NodeInput::value(TaggedValue::RasterData(Default::default()), true)],
 					manual_composition: Some(concrete!(Context)),
 					..Default::default()
 				},
@@ -1004,7 +1005,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 			node_template: NodeTemplate {
 				document_node: DocumentNode {
 					implementation: DocumentNodeImplementation::ProtoNode(memo::impure_memo::IDENTIFIER),
-					inputs: vec![NodeInput::value(TaggedValue::RasterData(RasterDataTable::default()), true)],
+					inputs: vec![NodeInput::value(TaggedValue::RasterData(Default::default()), true)],
 					manual_composition: Some(concrete!(Context)),
 					..Default::default()
 				},
@@ -1098,7 +1099,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 								..Default::default()
 							},
 							DocumentNode {
-								inputs: vec![NodeInput::network(concrete!(RasterDataTable<CPU>), 0), NodeInput::node(NodeId(0), 0)],
+								inputs: vec![NodeInput::network(concrete!(Table<Raster<CPU>>), 0), NodeInput::node(NodeId(0), 0)],
 								manual_composition: Some(generic!(T)),
 								implementation: DocumentNodeImplementation::ProtoNode(wgpu_executor::texture_upload::upload_texture::IDENTIFIER),
 								..Default::default()
@@ -1116,7 +1117,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						.collect(),
 						..Default::default()
 					}),
-					inputs: vec![NodeInput::value(TaggedValue::RasterData(RasterDataTable::default()), true)],
+					inputs: vec![NodeInput::value(TaggedValue::RasterData(Default::default()), true)],
 					..Default::default()
 				},
 				persistent_node_metadata: DocumentNodePersistentMetadata {
@@ -1195,7 +1196,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 		// 		document_node: DocumentNode {
 		// 			implementation: DocumentNodeImplementation::proto("graphene_core::raster::CurvesNode"),
 		// 			inputs: vec![
-		// 				NodeInput::value(TaggedValue::RasterData(RasterDataTable::default()), true),
+		// 				NodeInput::value(TaggedValue::RasterData(Default::default()), true),
 		// 				NodeInput::value(TaggedValue::Curve(Default::default()), false),
 		// 			],
 		// 			..Default::default()
@@ -1218,7 +1219,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						exports: vec![NodeInput::node(NodeId(1), 0)],
 						nodes: vec![
 							DocumentNode {
-								inputs: vec![NodeInput::network(concrete!(VectorDataTable), 0)],
+								inputs: vec![NodeInput::network(concrete!(Table<VectorData>), 0)],
 								implementation: DocumentNodeImplementation::ProtoNode(memo::monitor::IDENTIFIER),
 								manual_composition: Some(generic!(T)),
 								skip_deduplication: true,
@@ -1242,7 +1243,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						..Default::default()
 					}),
 					inputs: vec![
-						NodeInput::value(TaggedValue::VectorData(VectorDataTable::default()), true),
+						NodeInput::value(TaggedValue::VectorData(Default::default()), true),
 						NodeInput::value(TaggedValue::VectorModification(Default::default()), false),
 					],
 					..Default::default()
@@ -1373,7 +1374,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 							}),
 						),
 						InputMetadata::with_name_description_override("Align", "TODO", WidgetOverride::Custom("text_align".to_string())),
-						("Per-Glyph Instances", "Splits each text glyph into its own instance, i.e. row in the table of vector data.").into(),
+						("Per-Glyph Instances", "Splits each text glyph into its own row in the table of vector data.").into(),
 					],
 					output_names: vec!["Vector".to_string()],
 					..Default::default()
@@ -1495,7 +1496,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						exports: vec![NodeInput::node(NodeId(3), 0)],
 						nodes: vec![
 							DocumentNode {
-								inputs: vec![NodeInput::network(concrete!(VectorDataTable), 0), NodeInput::network(concrete!(vector::style::Fill), 1)],
+								inputs: vec![NodeInput::network(concrete!(Table<VectorData>), 0), NodeInput::network(concrete!(vector::style::Fill), 1)],
 								implementation: DocumentNodeImplementation::ProtoNode(path_bool::boolean_operation::IDENTIFIER),
 								manual_composition: Some(generic!(T)),
 								..Default::default()
@@ -1526,7 +1527,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						..Default::default()
 					}),
 					inputs: vec![
-						NodeInput::value(TaggedValue::GraphicGroup(GraphicGroupTable::default()), true),
+						NodeInput::value(TaggedValue::GraphicGroup(Default::default()), true),
 						NodeInput::value(TaggedValue::BooleanOperation(path_bool::BooleanOperation::Union), false),
 					],
 					..Default::default()
@@ -1593,14 +1594,14 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						exports: vec![NodeInput::node(NodeId(4), 0)],
 						nodes: [
 							DocumentNode {
-								inputs: vec![NodeInput::network(concrete!(graphene_std::vector::VectorDataTable), 0)],
+								inputs: vec![NodeInput::network(concrete!(Table<VectorData>), 0)],
 								implementation: DocumentNodeImplementation::ProtoNode(vector::subpath_segment_lengths::IDENTIFIER),
 								manual_composition: Some(generic!(T)),
 								..Default::default()
 							},
 							DocumentNode {
 								inputs: vec![
-									NodeInput::network(concrete!(graphene_std::vector::VectorDataTable), 0),
+									NodeInput::network(concrete!(Table<VectorData>), 0),
 									NodeInput::network(concrete!(vector::misc::PointSpacingType), 1),
 									NodeInput::network(concrete!(f64), 2),
 									NodeInput::network(concrete!(u32), 3),
@@ -1639,7 +1640,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						..Default::default()
 					}),
 					inputs: vec![
-						NodeInput::value(TaggedValue::VectorData(graphene_std::vector::VectorDataTable::default()), true),
+						NodeInput::value(TaggedValue::VectorData(Default::default()), true),
 						NodeInput::value(TaggedValue::PointSpacingType(Default::default()), false),
 						NodeInput::value(TaggedValue::F64(100.), false),
 						NodeInput::value(TaggedValue::U32(100), false),
@@ -1760,7 +1761,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						nodes: [
 							DocumentNode {
 								inputs: vec![
-									NodeInput::network(concrete!(graphene_std::vector::VectorDataTable), 0),
+									NodeInput::network(concrete!(Table<VectorData>), 0),
 									NodeInput::network(concrete!(f64), 1),
 									NodeInput::network(concrete!(u32), 2),
 								],
@@ -1794,7 +1795,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						..Default::default()
 					}),
 					inputs: vec![
-						NodeInput::value(TaggedValue::VectorData(graphene_std::vector::VectorDataTable::default()), true),
+						NodeInput::value(TaggedValue::VectorData(Default::default()), true),
 						NodeInput::value(TaggedValue::F64(10.), false),
 						NodeInput::value(TaggedValue::U32(0), false),
 					],

editor/src/messages/portfolio/document/node_graph/node_properties.rs

@@ -19,16 +19,14 @@ use graphene_std::raster::{
 	BlendMode, CellularDistanceFunction, CellularReturnType, Color, DomainWarpType, FractalType, LuminanceCalculation, NoiseType, RedGreenBlue, RedGreenBlueAlpha, RelativeAbsolute,
 	SelectiveColorChoice,
 };
-use graphene_std::raster_types::{CPU, GPU, RasterDataTable};
+use graphene_std::raster_types::{CPU, GPU, Raster};
+use graphene_std::table::Table;
 use graphene_std::text::{Font, TextAlign};
 use graphene_std::transform::{Footprint, ReferencePoint, Transform};
-use graphene_std::vector::VectorDataTable;
-use graphene_std::vector::misc::GridType;
-use graphene_std::vector::misc::{ArcType, MergeByDistanceAlgorithm};
-use graphene_std::vector::misc::{CentroidType, PointSpacingType};
-use graphene_std::vector::style::{Fill, FillChoice, FillType, GradientStops};
-use graphene_std::vector::style::{GradientType, PaintOrder, StrokeAlign, StrokeCap, StrokeJoin};
-use graphene_std::{GraphicGroupTable, NodeInputDecleration};
+use graphene_std::vector::VectorData;
+use graphene_std::vector::misc::{ArcType, CentroidType, GridType, MergeByDistanceAlgorithm, PointSpacingType};
+use graphene_std::vector::style::{Fill, FillChoice, FillType, GradientStops, GradientType, PaintOrder, StrokeAlign, StrokeCap, StrokeJoin};
+use graphene_std::{GraphicElement, NodeInputDecleration};
 
 pub(crate) fn string_properties(text: &str) -> Vec<LayoutGroup> {
 	let widget = TextLabel::new(text).widget_holder();
@@ -185,9 +183,9 @@ pub(crate) fn property_from_type(
 						// ====================
 						// GRAPHICAL DATA TYPES
 						// ====================
-						Some(x) if x == TypeId::of::<VectorDataTable>() => vector_data_widget(default_info).into(),
-						Some(x) if x == TypeId::of::<RasterDataTable<CPU>>() || x == TypeId::of::<RasterDataTable<GPU>>() => raster_widget(default_info).into(),
-						Some(x) if x == TypeId::of::<GraphicGroupTable>() => group_widget(default_info).into(),
+						Some(x) if x == TypeId::of::<Table<VectorData>>() => vector_data_widget(default_info).into(),
+						Some(x) if x == TypeId::of::<Table<Raster<CPU>>>() || x == TypeId::of::<Table<Raster<GPU>>>() => raster_widget(default_info).into(),
+						Some(x) if x == TypeId::of::<Table<GraphicElement>>() => group_widget(default_info).into(),
 						// ============
 						// STRUCT TYPES
 						// ============

editor/src/messages/portfolio/document/node_graph/utility_types.rs

@@ -18,18 +18,17 @@ pub enum FrontendGraphDataType {
 impl FrontendGraphDataType {
 	pub fn from_type(input: &Type) -> Self {
 		match TaggedValue::from_type_or_none(input) {
-			TaggedValue::Image(_) | TaggedValue::RasterData(_) => Self::Raster,
-			TaggedValue::Subpaths(_) | TaggedValue::VectorData(_) => Self::VectorData,
+			TaggedValue::RasterData(_) => Self::Raster,
+			TaggedValue::VectorData(_) => Self::VectorData,
 			TaggedValue::U32(_)
 			| TaggedValue::U64(_)
 			| TaggedValue::F64(_)
 			| TaggedValue::DVec2(_)
-			| TaggedValue::OptionalDVec2(_)
 			| TaggedValue::F64Array4(_)
 			| TaggedValue::VecF64(_)
 			| TaggedValue::VecDVec2(_)
 			| TaggedValue::DAffine2(_) => Self::Number,
-			TaggedValue::GraphicGroup(_) | TaggedValue::GraphicElement(_) => Self::Group, // TODO: Is GraphicElement supposed to be included here?
+			TaggedValue::GraphicGroup(_) => Self::Group,
 			TaggedValue::ArtboardGroup(_) => Self::Artboard,
 			_ => Self::General,
 		}

editor/src/messages/portfolio/document/overlays/overlays_message_handler.rs

@@ -91,10 +91,7 @@ impl MessageHandler<OverlaysMessage, OverlaysMessageContext<'_>> for OverlaysMes
 			}
 			#[cfg(all(not(target_family = "wasm"), test))]
 			OverlaysMessage::Draw => {
-				// Removes unused warnings in test builds
-				drop(responses);
-				drop(context);
-				drop(super::utility_types::OverlayContext::new(ipp.viewport_bounds.size(), device_pixel_ratio, visibility_settings));
+				let _ = (responses, visibility_settings, ipp, device_pixel_ratio);
 			}
 			OverlaysMessage::AddProvider(message) => {
 				self.overlay_providers.insert(message);

editor/src/messages/portfolio/document/utility_types/document_metadata.rs

@@ -22,7 +22,7 @@ use std::num::NonZeroU64;
 pub struct DocumentMetadata {
 	pub upstream_footprints: HashMap<NodeId, Footprint>,
 	pub local_transforms: HashMap<NodeId, DAffine2>,
-	pub first_instance_source_ids: HashMap<NodeId, Option<NodeId>>,
+	pub first_element_source_ids: HashMap<NodeId, Option<NodeId>>,
 	pub structure: HashMap<LayerNodeIdentifier, NodeRelations>,
 	pub click_targets: HashMap<LayerNodeIdentifier, Vec<ClickTarget>>,
 	pub clip_targets: HashSet<NodeId>,
@@ -91,7 +91,7 @@ impl DocumentMetadata {
 		let mut use_local = true;
 		let graph_layer = graph_modification_utils::NodeGraphLayer::new(layer, network_interface);
 		if let Some(path_node) = graph_layer.upstream_visible_node_id_from_name_in_layer("Path") {
-			if let Some(&source) = self.first_instance_source_ids.get(&layer.to_node()) {
+			if let Some(&source) = self.first_element_source_ids.get(&layer.to_node()) {
 				if !network_interface
 					.upstream_flow_back_from_nodes(vec![path_node], &[], FlowType::HorizontalFlow)
 					.any(|upstream| Some(upstream) == source)

editor/src/messages/portfolio/document/utility_types/network_interface.rs

@@ -13,7 +13,9 @@ use glam::{DAffine2, DVec2, IVec2};
 use graph_craft::document::value::TaggedValue;
 use graph_craft::document::{DocumentNode, DocumentNodeImplementation, NodeId, NodeInput, NodeNetwork, OldDocumentNodeImplementation, OldNodeNetwork};
 use graph_craft::{Type, concrete};
+use graphene_std::Artboard;
 use graphene_std::math::quad::Quad;
+use graphene_std::table::Table;
 use graphene_std::transform::Footprint;
 use graphene_std::vector::click_target::{ClickTarget, ClickTargetType};
 use graphene_std::vector::{PointId, VectorData, VectorModificationType};
@@ -507,8 +509,8 @@ impl NodeNetworkInterface {
 			InputConnector::Node { node_id, input_index } => (node_id, input_index),
 			InputConnector::Export(export_index) => {
 				let Some((encapsulating_node_id, encapsulating_node_id_path)) = network_path.split_last() else {
-					// The outermost network export defaults to an ArtboardGroupTable.
-					return Some((concrete!(graphene_std::ArtboardGroupTable), TypeSource::OuterMostExportDefault));
+					// The outermost network export defaults to a Table<Artboard>.
+					return Some((concrete!(Table<Artboard>), TypeSource::OuterMostExportDefault));
 				};
 
 				let output_type = self.output_type(encapsulating_node_id, export_index, encapsulating_node_id_path);
@@ -3558,8 +3560,8 @@ impl NodeNetworkInterface {
 	}
 
 	/// Update the cached first instance source id of the layers
-	pub fn update_first_instance_source_id(&mut self, new: HashMap<NodeId, Option<NodeId>>) {
-		self.document_metadata.first_instance_source_ids = new;
+	pub fn update_first_element_source_id(&mut self, new: HashMap<NodeId, Option<NodeId>>) {
+		self.document_metadata.first_element_source_ids = new;
 	}
 
 	/// Update the cached click targets of the layers
@@ -6609,11 +6611,22 @@ struct InputTransientMetadata {
 fn migrate_output_names<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Vec<String>, D::Error> {
 	use serde::Deserialize;
 
-	const REPLACEMENTS: [(&str, &str); 4] = [
-		("VectorData", "Instances<VectorData>"),
-		("GraphicGroup", "Instances<GraphicGroup>"),
-		("ImageFrame", "Instances<Image>"),
-		("Instances<ImageFrame>", "Instances<Image>"),
+	const REPLACEMENTS: [(&str, &str); 12] = [
+		// Single to table data
+		("VectorData", "Table<VectorData>"),
+		("GraphicGroup", "Table<GraphicGroup>"),
+		("ImageFrame", "Table<Image>"),
+		// `ImageFrame` to `Image` rename
+		("Instances<ImageFrame>", "Table<Image>"),
+		// `Instances` to `Table` rename
+		("Instances<VectorData>", "Table<VectorData>"),
+		("Instances<GraphicGroup>", "Table<GraphicGroup>"),
+		("Instances<Image>", "Table<Image>"),
+		("Instances<GraphicElement>", "Table<GraphicElement>"),
+		("Future<Instances<VectorData>>", "Future<Table<VectorData>>"),
+		("Future<Instances<GraphicGroup>>", "Future<Table<GraphicGroup>>"),
+		("Future<Instances<Image>>", "Future<Table<Image>>"),
+		("Future<Instances<GraphicElement>>", "Future<Table<GraphicElement>>"),
 	];
 
 	let mut names = Vec::<String>::deserialize(deserializer)?;

editor/src/messages/portfolio/document_migration.rs

@@ -10,10 +10,11 @@ use glam::IVec2;
 use graph_craft::document::DocumentNode;
 use graph_craft::document::{DocumentNodeImplementation, NodeInput, value::TaggedValue};
 use graphene_std::ProtoNodeIdentifier;
+use graphene_std::table::Table;
 use graphene_std::text::{TextAlign, TypesettingConfig};
 use graphene_std::uuid::NodeId;
+use graphene_std::vector::VectorData;
 use graphene_std::vector::style::{PaintOrder, StrokeAlign};
-use graphene_std::vector::{VectorData, VectorDataTable};
 use std::collections::HashMap;
 
 const TEXT_REPLACEMENTS: &[(&str, &str)] = &[
@@ -29,12 +30,12 @@ pub struct NodeReplacement<'a> {
 const NODE_REPLACEMENTS: &[NodeReplacement<'static>] = &[
 	// graphic element
 	NodeReplacement {
-		node: graphene_std::graphic_element::append_artboard::IDENTIFIER,
-		aliases: &["graphene_core::AddArtboardNode"],
+		node: graphene_std::artboard::append_artboard::IDENTIFIER,
+		aliases: &["graphene_core::AddArtboardNode", "graphene_core::graphic_element::AppendArtboardNode"],
 	},
 	NodeReplacement {
-		node: graphene_std::graphic_element::to_artboard::IDENTIFIER,
-		aliases: &["graphene_core::ConstructArtboardNode"],
+		node: graphene_std::artboard::to_artboard::IDENTIFIER,
+		aliases: &["graphene_core::ConstructArtboardNode", "graphene_core::graphic_element::ToArtboardNode"],
 	},
 	NodeReplacement {
 		node: graphene_std::graphic_element::to_element::IDENTIFIER,
@@ -386,7 +387,7 @@ const NODE_REPLACEMENTS: &[NodeReplacement<'static>] = &[
 	},
 	NodeReplacement {
 		node: graphene_std::raster_nodes::std_nodes::image_value::IDENTIFIER,
-		aliases: &["graphene_std::raster::ImageValueNode"],
+		aliases: &["graphene_std::raster::ImageValueNode", "graphene_std::raster::ImageNode"],
 	},
 	NodeReplacement {
 		node: graphene_std::raster_nodes::std_nodes::noise_pattern::IDENTIFIER,
@@ -616,7 +617,7 @@ fn migrate_node(node_id: &NodeId, node: &DocumentNode, network_path: &[NodeId],
 			return None;
 		};
 		let path_node = path_node_type.node_template_input_override([
-			Some(NodeInput::value(TaggedValue::VectorData(VectorDataTable::new(vector_data)), true)),
+			Some(NodeInput::value(TaggedValue::VectorData(Table::new_from_element(vector_data)), true)),
 			Some(NodeInput::value(TaggedValue::VectorModification(Default::default()), false)),
 		]);
 

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -54,7 +54,7 @@ pub struct PortfolioMessageHandler {
 	pub persistent_data: PersistentData,
 	pub executor: NodeGraphExecutor,
 	pub selection_mode: SelectionMode,
-	/// The spreadsheet UI allows for instance data to be previewed.
+	/// The spreadsheet UI allows for graph data to be previewed.
 	pub spreadsheet: SpreadsheetMessageHandler,
 	device_pixel_ratio: Option<f64>,
 	pub reset_node_definitions_on_open: bool,

editor/src/messages/portfolio/spreadsheet/spreadsheet_message.rs

@@ -1,7 +1,7 @@
 use crate::messages::prelude::*;
 use crate::node_graph_executor::InspectResult;
 
-/// The spreadsheet UI allows for instance data to be previewed.
+/// The spreadsheet UI allows for graph data to be previewed.
 #[impl_message(Message, PortfolioMessage, Spreadsheet)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum SpreadsheetMessage {
@@ -12,10 +12,10 @@ pub enum SpreadsheetMessage {
 		inspect_result: InspectResult,
 	},
 
-	PushToInstancePath {
+	PushToElementPath {
 		index: usize,
 	},
-	TruncateInstancePath {
+	TruncateElementPath {
 		len: usize,
 	},
 

editor/src/messages/portfolio/spreadsheet/spreadsheet_message_handler.rs

@@ -5,23 +5,22 @@ use crate::messages::tool::tool_messages::tool_prelude::*;
 use graph_craft::document::NodeId;
 use graphene_std::Color;
 use graphene_std::Context;
-use graphene_std::GraphicGroupTable;
-use graphene_std::instances::Instances;
 use graphene_std::memo::IORecord;
 use graphene_std::raster::Image;
-use graphene_std::vector::{VectorData, VectorDataTable};
-use graphene_std::{Artboard, ArtboardGroupTable, GraphicElement};
+use graphene_std::table::Table;
+use graphene_std::vector::VectorData;
+use graphene_std::{Artboard, GraphicElement};
 use std::any::Any;
 use std::sync::Arc;
 
-/// The spreadsheet UI allows for instance data to be previewed.
+/// The spreadsheet UI allows for graph data to be previewed.
 #[derive(Default, Debug, Clone, ExtractField)]
 pub struct SpreadsheetMessageHandler {
 	/// Sets whether or not the spreadsheet is drawn.
 	pub spreadsheet_view_open: bool,
 	inspect_node: Option<NodeId>,
 	introspected_data: Option<Arc<dyn Any + Send + Sync>>,
-	instances_path: Vec<usize>,
+	element_path: Vec<usize>,
 	viewing_vector_data_domain: VectorDataDomain,
 }
 
@@ -46,12 +45,12 @@ impl MessageHandler<SpreadsheetMessage, ()> for SpreadsheetMessageHandler {
 				self.update_layout(responses)
 			}
 
-			SpreadsheetMessage::PushToInstancePath { index } => {
-				self.instances_path.push(index);
+			SpreadsheetMessage::PushToElementPath { index } => {
+				self.element_path.push(index);
 				self.update_layout(responses);
 			}
-			SpreadsheetMessage::TruncateInstancePath { len } => {
-				self.instances_path.truncate(len);
+			SpreadsheetMessage::TruncateElementPath { len } => {
+				self.element_path.truncate(len);
 				self.update_layout(responses);
 			}
 
@@ -78,7 +77,7 @@ impl SpreadsheetMessageHandler {
 		}
 		let mut layout_data = LayoutData {
 			current_depth: 0,
-			desired_path: &mut self.instances_path,
+			desired_path: &mut self.element_path,
 			breadcrumbs: Vec::new(),
 			vector_data_domain: self.viewing_vector_data_domain,
 		};
@@ -91,7 +90,7 @@ impl SpreadsheetMessageHandler {
 
 		if layout_data.breadcrumbs.len() > 1 {
 			let breadcrumb = BreadcrumbTrailButtons::new(layout_data.breadcrumbs)
-				.on_update(|&len| SpreadsheetMessage::TruncateInstancePath { len: len as usize }.into())
+				.on_update(|&len| SpreadsheetMessage::TruncateElementPath { len: len as usize }.into())
 				.widget_holder();
 			layout.insert(0, LayoutGroup::Row { widgets: vec![breadcrumb] });
 		}
@@ -113,17 +112,17 @@ struct LayoutData<'a> {
 fn generate_layout(introspected_data: &Arc<dyn std::any::Any + Send + Sync + 'static>, data: &mut LayoutData) -> Option<Vec<LayoutGroup>> {
 	// We simply try random types. TODO: better strategy.
 	#[allow(clippy::manual_map)]
-	if let Some(io) = introspected_data.downcast_ref::<IORecord<Context, ArtboardGroupTable>>() {
+	if let Some(io) = introspected_data.downcast_ref::<IORecord<Context, Table<Artboard>>>() {
 		Some(io.output.layout_with_breadcrumb(data))
-	} else if let Some(io) = introspected_data.downcast_ref::<IORecord<(), ArtboardGroupTable>>() {
+	} else if let Some(io) = introspected_data.downcast_ref::<IORecord<(), Table<Artboard>>>() {
 		Some(io.output.layout_with_breadcrumb(data))
-	} else if let Some(io) = introspected_data.downcast_ref::<IORecord<Context, VectorDataTable>>() {
+	} else if let Some(io) = introspected_data.downcast_ref::<IORecord<Context, Table<VectorData>>>() {
 		Some(io.output.layout_with_breadcrumb(data))
-	} else if let Some(io) = introspected_data.downcast_ref::<IORecord<(), VectorDataTable>>() {
+	} else if let Some(io) = introspected_data.downcast_ref::<IORecord<(), Table<VectorData>>>() {
 		Some(io.output.layout_with_breadcrumb(data))
-	} else if let Some(io) = introspected_data.downcast_ref::<IORecord<Context, GraphicGroupTable>>() {
+	} else if let Some(io) = introspected_data.downcast_ref::<IORecord<Context, Table<GraphicElement>>>() {
 		Some(io.output.layout_with_breadcrumb(data))
-	} else if let Some(io) = introspected_data.downcast_ref::<IORecord<(), GraphicGroupTable>>() {
+	} else if let Some(io) = introspected_data.downcast_ref::<IORecord<(), Table<GraphicElement>>>() {
 		Some(io.output.layout_with_breadcrumb(data))
 	} else {
 		None
@@ -139,7 +138,7 @@ fn label(x: impl Into<String>) -> Vec<LayoutGroup> {
 	vec![LayoutGroup::Row { widgets: error }]
 }
 
-trait InstanceLayout {
+trait TableRowLayout {
 	fn type_name() -> &'static str;
 	fn identifier(&self) -> String;
 	fn layout_with_breadcrumb(&self, data: &mut LayoutData) -> Vec<LayoutGroup> {
@@ -149,14 +148,14 @@ trait InstanceLayout {
 	fn compute_layout(&self, data: &mut LayoutData) -> Vec<LayoutGroup>;
 }
 
-impl InstanceLayout for GraphicElement {
+impl TableRowLayout for GraphicElement {
 	fn type_name() -> &'static str {
 		"GraphicElement"
 	}
 	fn identifier(&self) -> String {
 		match self {
-			Self::GraphicGroup(instances) => instances.identifier(),
-			Self::VectorData(instances) => instances.identifier(),
+			Self::GraphicGroup(table) => table.identifier(),
+			Self::VectorData(table) => table.identifier(),
 			Self::RasterDataCPU(_) => "RasterDataCPU".to_string(),
 			Self::RasterDataGPU(_) => "RasterDataGPU".to_string(),
 		}
@@ -167,15 +166,15 @@ impl InstanceLayout for GraphicElement {
 	}
 	fn compute_layout(&self, data: &mut LayoutData) -> Vec<LayoutGroup> {
 		match self {
-			Self::GraphicGroup(instances) => instances.layout_with_breadcrumb(data),
-			Self::VectorData(instances) => instances.layout_with_breadcrumb(data),
+			Self::GraphicGroup(table) => table.layout_with_breadcrumb(data),
+			Self::VectorData(table) => table.layout_with_breadcrumb(data),
 			Self::RasterDataCPU(_) => label("Raster frame not supported"),
 			Self::RasterDataGPU(_) => label("Raster frame not supported"),
 		}
 	}
 }
 
-impl InstanceLayout for VectorData {
+impl TableRowLayout for VectorData {
 	fn type_name() -> &'static str {
 		"VectorData"
 	}
@@ -243,7 +242,7 @@ impl InstanceLayout for VectorData {
 	}
 }
 
-impl InstanceLayout for Image<Color> {
+impl TableRowLayout for Image<Color> {
 	fn type_name() -> &'static str {
 		"Image"
 	}
@@ -256,7 +255,7 @@ impl InstanceLayout for Image<Color> {
 	}
 }
 
-impl InstanceLayout for Artboard {
+impl TableRowLayout for Artboard {
 	fn type_name() -> &'static str {
 		"Artboard"
 	}
@@ -268,18 +267,18 @@ impl InstanceLayout for Artboard {
 	}
 }
 
-impl<T: InstanceLayout> InstanceLayout for Instances<T> {
+impl<T: TableRowLayout> TableRowLayout for Table<T> {
 	fn type_name() -> &'static str {
-		"Instances"
+		"Table"
 	}
 	fn identifier(&self) -> String {
-		format!("Instances<{}> (length={})", T::type_name(), self.len())
+		format!("Table<{}> (length={})", T::type_name(), self.len())
 	}
 	fn compute_layout(&self, data: &mut LayoutData) -> Vec<LayoutGroup> {
 		if let Some(index) = data.desired_path.get(data.current_depth).copied() {
-			if let Some(instance) = self.get(index) {
+			if let Some(row) = self.get(index) {
 				data.current_depth += 1;
-				let result = instance.instance.layout_with_breadcrumb(data);
+				let result = row.element.layout_with_breadcrumb(data);
 				data.current_depth -= 1;
 				return result;
 			} else {
@@ -289,16 +288,16 @@ impl<T: InstanceLayout> InstanceLayout for Instances<T> {
 		}
 
 		let mut rows = self
-			.instance_ref_iter()
+			.iter_ref()
 			.enumerate()
-			.map(|(index, instance)| {
-				let (scale, angle, translation) = instance.transform.to_scale_angle_translation();
+			.map(|(index, row)| {
+				let (scale, angle, translation) = row.transform.to_scale_angle_translation();
 				let rotation = if angle == -0. { 0. } else { angle.to_degrees() };
 				let round = |x: f64| (x * 1e3).round() / 1e3;
 				vec![
 					TextLabel::new(format!("{}", index)).widget_holder(),
-					TextButton::new(instance.instance.identifier())
-						.on_update(move |_| SpreadsheetMessage::PushToInstancePath { index }.into())
+					TextButton::new(row.element.identifier())
+						.on_update(move |_| SpreadsheetMessage::PushToElementPath { index }.into())
 						.widget_holder(),
 					TextLabel::new(format!(
 						"Location: ({} px, {} px) — Rotation: {rotation:2}° — Scale: ({}x, {}x)",
@@ -308,15 +307,15 @@ impl<T: InstanceLayout> InstanceLayout for Instances<T> {
 						round(scale.y)
 					))
 					.widget_holder(),
-					TextLabel::new(format!("{}", instance.alpha_blending)).widget_holder(),
-					TextLabel::new(instance.source_node_id.map_or_else(|| "-".to_string(), |id| format!("{}", id.0))).widget_holder(),
+					TextLabel::new(format!("{}", row.alpha_blending)).widget_holder(),
+					TextLabel::new(row.source_node_id.map_or_else(|| "-".to_string(), |id| format!("{}", id.0))).widget_holder(),
 				]
 			})
 			.collect::<Vec<_>>();
 
-		rows.insert(0, column_headings(&["", "instance", "transform", "alpha_blending", "source_node_id"]));
+		rows.insert(0, column_headings(&["", "element", "transform", "alpha_blending", "source_node_id"]));
 
-		let instances = vec![TextLabel::new("Instances:").widget_holder()];
-		vec![LayoutGroup::Row { widgets: instances }, LayoutGroup::Table { rows }]
+		let table = vec![TextLabel::new("Table:").widget_holder()];
+		vec![LayoutGroup::Row { widgets: table }, LayoutGroup::Table { rows }]
 	}
 }

editor/src/messages/tool/common_functionality/graph_modification_utils.rs

@@ -11,7 +11,8 @@ use graph_craft::{ProtoNodeIdentifier, concrete};
 use graphene_std::Color;
 use graphene_std::NodeInputDecleration;
 use graphene_std::raster::BlendMode;
-use graphene_std::raster_types::{CPU, GPU, RasterDataTable};
+use graphene_std::raster_types::{CPU, GPU, Raster};
+use graphene_std::table::Table;
 use graphene_std::text::{Font, TypesettingConfig};
 use graphene_std::vector::style::Gradient;
 use graphene_std::vector::{ManipulatorPointId, PointId, SegmentId, VectorModificationType};
@@ -211,7 +212,7 @@ pub fn new_vector_layer(subpaths: Vec<Subpath<PointId>>, id: NodeId, parent: Lay
 }
 
 /// Create a new bitmap layer.
-pub fn new_image_layer(image_frame: RasterDataTable<CPU>, id: NodeId, parent: LayerNodeIdentifier, responses: &mut VecDeque<Message>) -> LayerNodeIdentifier {
+pub fn new_image_layer(image_frame: Table<Raster<CPU>>, id: NodeId, parent: LayerNodeIdentifier, responses: &mut VecDeque<Message>) -> LayerNodeIdentifier {
 	let insert_index = 0;
 	responses.add(GraphOperationMessage::NewBitmapLayer {
 		id,
@@ -475,6 +476,6 @@ impl<'a> NodeGraphLayer<'a> {
 	pub fn is_raster_layer(layer: LayerNodeIdentifier, network_interface: &mut NodeNetworkInterface) -> bool {
 		let layer_input_type = network_interface.input_type(&InputConnector::node(layer.to_node(), 1), &[]).0.nested_type().clone();
 
-		layer_input_type == concrete!(RasterDataTable<CPU>) || layer_input_type == concrete!(RasterDataTable<GPU>)
+		layer_input_type == concrete!(Table<Raster<CPU>>) || layer_input_type == concrete!(Table<Raster<GPU>>)
 	}
 }

editor/src/messages/tool/common_functionality/utility_functions.rs

@@ -14,8 +14,9 @@ use glam::{DAffine2, DVec2};
 use graph_craft::concrete;
 use graph_craft::document::value::TaggedValue;
 use graphene_std::renderer::Quad;
+use graphene_std::table::Table;
 use graphene_std::text::{FontCache, load_font};
-use graphene_std::vector::{HandleExt, HandleId, ManipulatorPointId, PointId, SegmentId, VectorData, VectorDataTable, VectorModification, VectorModificationType};
+use graphene_std::vector::{HandleExt, HandleId, ManipulatorPointId, PointId, SegmentId, VectorData, VectorModification, VectorModificationType};
 use kurbo::{CubicBez, Line, ParamCurveExtrema, PathSeg, Point, QuadBez};
 
 /// Determines if a path should be extended. Goal in viewport space. Returns the path and if it is extending from the start, if applicable.
@@ -76,7 +77,7 @@ pub fn text_bounding_box(layer: LayerNodeIdentifier, document: &DocumentMessageH
 	let font_data = font_cache.get(font).map(|data| load_font(data));
 	let far = graphene_std::text::bounding_box(text, font_data, typesetting, false);
 
-	// TODO: Once the instances refactor is complete and per_glyph_instances can be removed (since it'll be the default),
+	// TODO: Once the instance tables refactor is complete and per_glyph_instances can be removed (since it'll be the default),
 	// TODO: remove this because the top of the dashed bounding overlay should no longer be based on the first line's baseline.
 	let vertical_offset = if per_glyph_instances {
 		DVec2::NEG_Y * typesetting.font_size * (1. + (typesetting.line_height_ratio - 1.) / 2.)
@@ -599,13 +600,13 @@ pub fn make_path_editable_is_allowed(network_interface: &NodeNetworkInterface, m
 		return None;
 	}
 
-	// Must be a layer of type VectorDataTable
+	// Must be a layer of type Table<VectorData>
 	let compatible_type = NodeGraphLayer::new(first_layer, network_interface)
 		.horizontal_layer_flow()
 		.nth(1)
 		.map(|node_id| {
 			let (output_type, _) = network_interface.output_type(&node_id, 0, &[]);
-			output_type.nested_type() == concrete!(VectorDataTable).nested_type()
+			output_type.nested_type() == concrete!(Table<VectorData>).nested_type()
 		})
 		.unwrap_or_default();
 	if !compatible_type {

editor/src/messages/tool/tool_messages/artboard_tool.rs

@@ -12,6 +12,7 @@ use crate::messages::tool::common_functionality::snapping::SnapManager;
 use crate::messages::tool::common_functionality::transformation_cage::*;
 use graph_craft::document::NodeId;
 use graphene_std::renderer::Quad;
+use graphene_std::table::Table;
 
 #[derive(Default, ExtractField)]
 pub struct ArtboardTool {
@@ -337,7 +338,7 @@ impl Fsm for ArtboardToolFsmState {
 					responses.add(GraphOperationMessage::NewArtboard {
 						id,
 						artboard: graphene_std::Artboard {
-							graphic_group: graphene_std::GraphicGroupTable::default(),
+							graphic_group: Table::new(),
 							label: String::from("Artboard"),
 							location: start.min(end).round().as_ivec2(),
 							dimensions: (start.round() - end.round()).abs().as_ivec2(),
@@ -568,7 +569,7 @@ mod test_artboard {
 			Ok(instrumented) => instrumented,
 			Err(e) => panic!("Failed to evaluate graph: {}", e),
 		};
-		instrumented.grab_all_input::<graphene_std::graphic_element::append_artboard::ArtboardInput>(&editor.runtime).collect()
+		instrumented.grab_all_input::<graphene_std::artboard::append_artboard::ArtboardInput>(&editor.runtime).collect()
 	}
 
 	#[tokio::test]

editor/src/node_graph_executor.rs

@@ -388,7 +388,7 @@ impl NodeGraphExecutor {
 		let graphene_std::renderer::RenderMetadata {
 			upstream_footprints: footprints,
 			local_transforms,
-			first_instance_source_id,
+			first_element_source_id,
 			click_targets,
 			clip_targets,
 		} = render_output_metadata;
@@ -397,7 +397,7 @@ impl NodeGraphExecutor {
 		responses.add(DocumentMessage::UpdateUpstreamTransforms {
 			upstream_footprints: footprints,
 			local_transforms,
-			first_instance_source_id,
+			first_element_source_id,
 		});
 		responses.add(DocumentMessage::UpdateClickTargets { click_targets });
 		responses.add(DocumentMessage::UpdateClipTargets { clip_targets });

editor/src/node_graph_executor/runtime.rs

@@ -9,13 +9,13 @@ use graph_craft::wasm_application_io::EditorPreferences;
 use graph_craft::{ProtoNodeIdentifier, concrete};
 use graphene_std::Context;
 use graphene_std::application_io::{ImageTexture, NodeGraphUpdateMessage, NodeGraphUpdateSender, RenderConfig};
-use graphene_std::instances::Instance;
 use graphene_std::memo::IORecord;
 use graphene_std::renderer::{GraphicElementRendered, RenderParams, SvgRender};
 use graphene_std::renderer::{RenderSvgSegmentList, SvgSegment};
+use graphene_std::table::{Table, TableRow};
 use graphene_std::text::FontCache;
+use graphene_std::vector::VectorData;
 use graphene_std::vector::style::ViewMode;
-use graphene_std::vector::{VectorData, VectorDataTable};
 use graphene_std::wasm_application_io::{RenderOutputType, WasmApplicationIo, WasmEditorApi};
 use interpreted_executor::dynamic_executor::{DynamicExecutor, IntrospectError, ResolvedDocumentNodeTypesDelta};
 use interpreted_executor::util::wrap_network_in_scope;
@@ -313,12 +313,10 @@ impl NodeRuntime {
 			} else if let Some(io) = introspected_data.downcast_ref::<IORecord<Context, graphene_std::Artboard>>() {
 				Self::process_graphic_element(&mut self.thumbnail_renders, parent_network_node_id, &io.output, responses, update_thumbnails)
 			// Insert the vector modify if we are dealing with vector data
-			} else if let Some(record) = introspected_data.downcast_ref::<IORecord<Context, VectorDataTable>>() {
-				let default = Instance::default();
-				self.vector_modify.insert(
-					parent_network_node_id,
-					record.output.instance_ref_iter().next().unwrap_or_else(|| default.to_instance_ref()).instance.clone(),
-				);
+			} else if let Some(record) = introspected_data.downcast_ref::<IORecord<Context, Table<VectorData>>>() {
+				let default = TableRow::default();
+				self.vector_modify
+					.insert(parent_network_node_id, record.output.iter_ref().next().unwrap_or_else(|| default.as_ref()).element.clone());
 			} else {
 				log::warn!("Failed to downcast monitor node output {parent_network_node_id:?}");
 			}