Make the data model use Item and List types universally, with nodes authored as rank-polymorphic kernels (#4335)

* Add rank polymorphism node audit classifying all 271 nodes * Implement StaticType for Item<T> * Generate Item and mapped List wire variants for nodes declaring an Item<T> primary input * Migrate nine nodes to Item element-wise kernels, dissolving the blending trait boilerplate * Document the Item kernel implementation and staging plan * Route Item<Vector> through TaggedValue::TypeDefault * Add executor integration tests covering the Item and List wire variants * Collapse element-wise Item/List wire pairs to the List form for conversion insertion * Migrate sixteen vector modifier nodes to Item element-wise kernels * Migrate Sample Image, Extend Image to Bounds, and Dehaze to Item element-wise kernels * Fix bevel_with_transform test to actually exercise the transform attribute * Implement From<T> for Item<T> * Register PromoteNode rank adapters wrapping bare values into Item wires * Insert PromoteNode adapters for Item/List wire pair fields in the preprocessor * Define a real promote node backing the PromoteNode registry identifiers * Zip ranked Item connectors by frame slot in the mapped element-wise variant * Register ItemToListNode singleton raise adapters * Resolve Item wires against List connectors by inserting promotion adapters at construction * Rank the Offset Points distance connector and prove mixed-rank resolution end-to-end * Implement Clampable for Item and List wires with per-variant clamp bounds * Rank the Round Corners radius connector, exercising hard bounds on a ranked wire * Implement ApplyTransform for Item * Add Item wire implementations to the Transform node, keeping rank-0 chains rank 0 * Detect element-wise nodes by lazy primary connectors declaring Output = Item * Convert Transform to an Item kernel with ranked parameters, delivering the broadcast milestone * Rename Apply Transform to Bake Transform, baking item transforms on Vector, DAffine2, and DVec2 * Promote bare wires onto Item connectors at resolution via WrapItemNode adapters * Rank the numeric, vector, and boolean parameters across the migrated element-wise nodes * Rank the enum, integer, and seed parameters, registering their rank adapters via a consolidated macro * Amend the audit with the DashPattern value type resolution * Migrate the string family to Item element-wise kernels * Unwrap Item wires into bare legacy connectors at resolution via UnwrapItemNode adapters * Shadow owned node parameters in bodies instead of mut in signatures * Migrate the math family and string measure nodes to Item element-wise kernels * Convert the comparison and clamp nodes to Item kernels, dropping unreachable &str rows * Flat-map expander kernels returning List under the mapped variant's frame * Migrate the expander nodes to Item kernels flat-mapping under the frame * Remove the unused peel_list helper * Rank the raster adjustment and blending kernels, recontextualizing shader nodes onto an Item stand-in Migrate the 16 adjustment nodes, Mix, Color Overlay, and Gradient Map from whole-List kernels to rank-0 Item kernels, letting the macro derive the List-mapped (zip) variants. Move the Adjust and Blend per-element seams off List onto the element types (add the Raster<CPU> impls, drop the now-dead List impls). Shader nodes keep their bodies verbatim: PerPixelAdjust re-emits the identical kernel against a transparent no_std Item stand-in, so every Item<T> connector and .element() call resolves to a zero-cost identity on the GPU while the uniform buffer stays bare repr(C). The macro peels Item off ranked uniform params, wraps the fetched texel and uniforms at the entry point, and unwraps the result. This drops the shader_node/Item incompatibility guard. Register rank adapters for the adjustment enums. * Update the rank polymorphism roadmap for the landed shader-node and adjustments chunk * Rename the GPU Item stand-in to ShaderItem, aliased as Item at its shader-node import sites * Flip the vector shape generators to emit rank-0 Item<Vector> The shape generators (Rectangle, Circle, Ellipse, Arc, Spiral, Polygon, Star, Arrow, Line, Grid, QR Code) each produced exactly one shape wrapped in a singleton List<Vector>. Emit Item<Vector> directly so they connect to the rank-0 content connector of the migrated Transform node. Downstream List consumers receive the value through the existing Item to List promotion. Relax the element-wise validation so a `()` (generator) primary may return Item<T> without being element-wise. Adapt the Repeat on Points test, which still takes a List content connector, by raising the generator's Item output through a singleton wrapper node. * Parse ranked Item<T> parameter defaults against the bare element type A ranked `Item<T>` parameter's default value is a bare, unranked `T` (promoted to the wire at resolution), but the preprocessor was handed the wrapped `Item<T>` type and could not parse the literal, flooding the console with warnings and dropping the defaults. Key the field's default_type metadata off the peeled element type for concrete ranked parameters, leaving generic `Item<T>` primaries and skip_impl nodes untouched. * Parse an element-wise primary's scalar default against the bare element type An element-wise node's primary reports its default_type as the List wire form so an unconnected primary defaults to an empty list. But when the primary carries a scalar `#[default]` (such as Root's radicand), that literal must parse as a bare element, not a List. Key the primary's default_type off the bare element type when it has a Default value source, keeping the List form otherwise. * Add the DashPattern value type for stroke dash sequences Introduce a rank-0 DashPattern value type (a Vec<f64> of alternating dash and gap lengths) so a stroke's dash pattern is a single frameable value rather than a rank-1 List<f64>. Register it as an auto-generated TaggedValue variant, parse its default from a comma or space separated string, and register its rank adapters. Not yet wired into the Stroke node. * Rank the Fill and Stroke nodes element-wise and give Stroke a DashPattern connector Migrate Fill and Stroke to element-wise Item<V> primaries (over Vector and Graphic element types) via a new element-level VectorItemMut trait, so styling one shape yields one shape and rank is preserved instead of promoting the input to a singleton List and emitting a List. The macro derives the List-mapped variant for genuine collections. Wire the Stroke dash sequence to the new rank-0 DashPattern value type, collapsing the old content x paint x dash cartesian and dropping the IntoF64Vec trait. Update the stroke properties dash widget, the drawing tool, and graph-operation plumbing to read and write DashPattern, and migrate legacy F64Array, F64, and String dash inputs on document open. Assign Colors stays a whole-collection node: each element's gradient position depends on its index among all siblings, which the element frame does not expose, so it keeps its List primary and the VectorListIterMut trait. * Register rank adapters for the ranked Stroke enum parameters The element-wise Stroke node ranks its align, cap, and paint order parameters as Item<StrokeAlign>, Item<StrokeCap>, and Item<PaintOrder>, but those enums lacked promotion adapters, so a bare default enum value could not be promoted to its Item wire and no Stroke variant resolved ("No construct found for node"). Register their rank adapters alongside StrokeJoin. * Display Item wires in the Data panel without a List's ID column Add a TableItemLayout impl for Item<T> and recognize Item wire types when introspecting graph data. An Item holds a single element, so it renders as a one-row table of the element plus its attributes with no leading index column, and it labels as its element type T rather than a List's T[]. Add ItemAttributeValues::get_any for the attribute widget dispatch. * Register MonitorNode for Item wire types so the Data panel introspects them directly Graph introspection wraps the inspected output in a generic MonitorNode typed to the wire. Without Item<T> monitor registrations, an Item<Vector> output could only be monitored after an Item to List promotion, so the Data panel captured and displayed a List<Vector> despite the connector being Item<Vector>. Register monitors for the Item types the element-wise nodes emit, and add the matching Data panel downcast entries. * Color and double Item/List wires and cleave layer-stack connectors in the node graph * Route wire color and rank through hidden nodes and refresh them on type changes * Rework the DashPattern connector conversions with element-wise promotion and an explicit reducer node * Rank the remaining value, context, aggregation, and transform nodes onto Item<T> wires * Back DashPattern with a List<f64> so the Data panel can introspect its lengths * Carry a single Item<T> through varargs so the Read context nodes emit Item<T> not List<T> * Relax rank validation for aggregation shapes, add element adapters, and match variants by fewest promotions * Rank the remaining bare and unnecessarily-List connectors across the node catalog * Add Graphic::None and the FillChoice paint value, making colors and gradients plain values * Rename GradientStops to Gradient and the legacy Gradient/Fill structs to LegacyGradient/LegacyFill * Restore generator frame-from-params ranking to the roadmap as a planned stage * Rename the ranked-field adapter identifier from PromoteNode to FieldAdapterNode to reflect its full contract * Unload only the wires whose displayed style changed when types update * Peel wire rank in the editor's semantic type checks so rank-0 layers are recognized * Restore the whole-List Transform variant so rank-1 content wires resolve again * Register the Item wire forms for the Memoize and Context Modification infrastructure nodes * Give every ranked connector a field adapter and add numeric cast variants for legacy wires * Key a ranked param's type default off its Item wire form when no literal default exists * Inherit the layer's content value when splicing a node into an empty chain * Migrate stale List-form TypeDefault inputs to the definition's current default * Generate the mapped wire variant only when the element-wise node has a frame source * Let a bare wire feed a List connector via a wrap-raise adapter, costed as two rank steps * Add a zip companion to the whole-List Transform so ranked List parameters pair per slot * Add the Sum, Average, Minimum, Maximum, Any, and All list reducers * Convert the measure family to element-wise Item kernels per the audit classification * Prefer the bare element value over the Item type default so ranked params keep their widgets * Rename GradientStopsUI to GradientUI * Split Fill's optional transform into a _has_transform bool and a ranked _transform matrix * Rename the migration-only OptionalDAffine2 TaggedValue to LegacyOptionalDAffine2 * Flow byte buffers as Item<Resource> instead of List<u8> across the byte nodes * Macro-generate the list-content wire variant, retiring the hand-written Transform-zip, Area, and Centroid companions * Let ()-primary generators take ranked params and frame over them via the mapped variant, ranking Circle's radius * Rank the vector shape generators' params to Item, adding a rank-aware input grab to the introspection harness * Rank the value, color, and text generator params to Item * Rank the raster, web-request, and context-reader generator params to Item * Fix the repeat and brush test wirings left behind by the param-ranking sweeps * Delete the vestigial Some, Unwrap Option, and Size Of debug nodes * Delete the Attach Attribute node, folding its role into Write Attribute * Add the Filter and Sort list companion nodes * Guard the removed-definition migration swap target with a test * Add the Box Corners value type in place of the rectangle corner radius list * Split Text to Vector's per-glyph mode into a Text to Vector Glyphs node * Rank the Combine Channels node's channel connectors to Item * Make Map Points an element-wise node * Delete the deprecated Upload Texture node * Update the implementation roadmap to reflect the landed stages * Let monitor introspection read rank-0 wires, locking in the layer coercion promotion path * Prefer the rank-0 default when disconnecting a rank-capable input * Make Path Modify an element-wise node * Wrap node paths in a NodeIdPath newtype so they flow as a single Item * Give Item<Raster<CPU>> a default so an unconnected Brush background resolves * Stop the Brush node from setting layer attributes its paint operation doesn't produce * Present-gate Flatten Path's adopted layer path like its fill and stroke * Gate carried layer attributes on static column presence, not runtime values * Give the remaining graphic Item<T> types a default so unconnected primaries resolve * Dispatch a ranked param's Properties widget from its rank-0 element type * Make Extract Transform an element-wise node, restoring the Origins to Polyline body * Rename Flatten Path to Combine Paths * Stamp Legacy Layer Extend's adopted layer path as a readable NodeIdPath * Drop the dead List<u8> and List<NodeId> wire rows * Rank Flatten Graphic's Fully Flatten toggle to Item * Update the implementation roadmap with the endgame scope * Make Combine Paths a reducer that collapses the whole frame into one path * Stop type-converter nodes from carrying the source's unrelated attributes * Format the Origins to Polyline regression test * Wrap the Brush node's trace in a BrushTrace newtype so it flows as one value * Make Switch a framed element-wise select, bundling whole collections * Widen and align element-type coverage across the list and graphic nodes * Register the compiler's cache chain pair for every ranked enum and newtype wire * Fix wire colors for Passthrough outputs, bundled lists, and bools, and widen list wires * Represent List wire types structurally with Type::List, replacing name-parsed rank promotion * Treat scope and data fields as environment, rank scope wires as Item, and feed the render boundary through a context vararg * Delete the vestigial Clone debug node * Reinstate Upload Texture as an element-wise node and fix the GPU variants' scope executor and rank adapters * Rename Combine Paths back to Flatten Path, deferring that rename to its own PR * Deduplicate the promotion adapter registrations into the field adapter macro * Rank Write Attribute's value connector to Item<AttributeValueDyn>, retiring the UnwrapItem bridge * Vertical wire styling * Store the editor layer path attribute as a bare NodeIdPath, not an Item<NodeIdPath> * Rank Context Modification's features connector to Item<ContextFeatures>, dropping the dead memoize row * Rank Path Modify's modification parameter to Item<Box<VectorModification>> * Rename the field adapter node family to input adapter * Drop the dead bare scalar rows from Context Modification's implementations list * Move the dynamic executor's test module into its own file * Drop the registry's unreachable bare rows for Memoize, the cache chain, and ConvertNode * Materialize stored TaggedValues as ranked Item wires at the source * Remove the bare-wire promotion and adapter machinery made dead by ranked value materialization * Plant the input adapter for List-only inputs, composing position conversion from standard rows * Consolidate Into/Convert conversions into the input adapter umbrella and rename the rank adapter identifiers * Fix grouped layers gaining a phantom None stack element from the FillChoice default hijacking every List<Graphic> disconnect * Enforce ranked node inputs in the macro, rejecting bare wire declarations * Remove the unit Context => () machinery rows, leaving () purely as the no-primary sentinel * Add a --signatures rank-audit mode to node-docs for the ranked-wire migration * Remove the node-docs --signatures rank-audit mode now that ranked wires are enforced * Migrate legacy no-color values on the Black & White, Color Overlay, and Empty Image color inputs * Rewrite the element-wise accessor wire type at the primary input, not raw index 0 * Register the cache chain for Resource wires, replacing the lone hand-written Monitor row * Gate the remaining Raster<GPU> registry rows behind the gpu feature * Let List<DVec2> wires erase to ListDyn for the attribute reader and element counter * Rename Extract Element to Item at Index, Count Elements to List Length, and Omit Element to Remove at Index * Store paint picks as plain color/gradient values, removing the FillChoice value type * Code review restructuring * Sort by the consumed sort_key attribute or natural element order, adding the Sort Key node * Remove the new list-combinator and reducer nodes to defer them to a follow-up PR * Parse Fill and Stroke color defaults through the paint wire's Graphic element * Emit ranked implementation-row default types structurally so their element TypeIds survive to default-literal parsing * Exempt the deliberate no-paint choice from the stale List-form TypeDefault migration * Migrate the legacy 4-input Fill directly to the split has-transform shape * Upgrade the demo artwork * Fix the valid AI review findings: Item eq/hash contract, table-era no-paint migration, quantize List rows, and other smaller issues * Remove the rank polymorphism working documents * Hash Item attribute values directly instead of debug-formatting them, speeding up cached evaluation * Replace the data panel's dead bare-wire downcast arms with full coverage of the ranked monitor row types * Derive PartialEq for Item now that attributes participate in equality * Extend the data panel's attribute dispatchers with the newly supported scalar and choice enum types * Add List monitor rows for the framed numeric conversion outputs so inspecting them resolves, with matching data panel arms
2026-10-06 20:28:13 +08:00 · 2026-09-08 16:03:01 +00:00
parent 296185b7fc
commit a708a54492
3257 changed files with 766342 additions and 1829 deletions
@@ -0,0 +1,19 @@
+[package]
+name = "graphic-nodes"
+version = "0.1.0"
+edition = "2024"
+license = "MIT OR Apache-2.0"
+authors.workspace = true
+
+[dependencies]
+# Local dependencies
+core-types = { workspace = true }
+graphic-types = { workspace = true }
+vector-types = { workspace = true }
+raster-types = { workspace = true }
+
+# Workspace dependencies
+dyn-any = { workspace = true }
+glam = { workspace = true }
+serde = { workspace = true }
+node-macro = { workspace = true }
@@ -0,0 +1,60 @@
+use core_types::list::{Item, List};
+use core_types::transform::TransformMut;
+use core_types::{ATTR_BACKGROUND, ATTR_CLIP, ATTR_DIMENSIONS, ATTR_LOCATION, CloneVarArgs, Color, Context, Ctx, ExtractAll, OwnedContextImpl};
+use glam::{DAffine2, DVec2};
+use graphic_types::graphic::{Graphic, IntoGraphicList};
+use graphic_types::{Artboard, Vector};
+use raster_types::{CPU, GPU, Raster};
+use vector_types::GradientStops;
+
+/// Constructs a single-element `Artboard[]` with the given content and metadata stored as row attributes.
+#[node_macro::node(category(""))]
+pub async fn create_artboard<T: IntoGraphicList>(
+	ctx: impl ExtractAll + CloneVarArgs + Ctx,
+	/// Graphics to include within the artboard.
+	#[implementations(
+		Context -> List<Graphic>,
+		Context -> List<Vector>,
+		Context -> List<String>,
+		Context -> List<Raster<CPU>>,
+		Context -> List<Raster<GPU>>,
+		Context -> List<Color>,
+		Context -> List<GradientStops>,
+		Context -> DAffine2,
+	)]
+	content: impl Node<Context<'static>, Output = T>,
+	/// Coordinate of the top-left corner of the artboard within the document.
+	location: DVec2,
+	/// Width and height of the artboard within the document.
+	dimensions: DVec2,
+	/// Color of the artboard background.
+	background: List<Color>,
+	/// Whether to cut off the contained content that extends outside the artboard, or keep it visible.
+	#[default(true)]
+	clip: bool,
+) -> List<Artboard> {
+	let footprint = ctx.try_footprint().copied();
+	let mut new_ctx = OwnedContextImpl::from(ctx);
+	if let Some(mut footprint) = footprint {
+		footprint.translate(location);
+		new_ctx = new_ctx.with_footprint(footprint);
+	}
+	let content = content.eval(new_ctx.into_context()).await.into_graphic_list();
+
+	// Normalize so `location` is the top-left corner and `dimensions` are positive (allowing negative input
+	// dimensions to represent dragging from the opposite corner). Compute the corner using the raw signed
+	// dimensions before clamping, otherwise negative inputs collapse to the original corner instead of inverting.
+	let normalized_location = location.min(location + dimensions);
+	let normalized_dimensions = dimensions.abs().max(DVec2::ONE);
+
+	let background = background.element(0).copied().unwrap_or(Color::WHITE);
+
+	// Name is not stored here, it's resolved live from the parent layer's display name
+	List::new_from_item(
+		Item::new_from_element(Artboard::new(content))
+			.with_attribute(ATTR_LOCATION, normalized_location)
+			.with_attribute(ATTR_DIMENSIONS, normalized_dimensions)
+			.with_attribute(ATTR_BACKGROUND, background)
+			.with_attribute(ATTR_CLIP, clip),
+	)
+}
@@ -0,0 +1,714 @@
+use core_types::bounds::{BoundingBox, RenderBoundingBox};
+use core_types::list::{AttributeDyn, AttributeValueDyn, Item, List, ListDyn};
+use core_types::registry::types::{Angle, SignedInteger};
+use core_types::uuid::NodeId;
+use core_types::{ATTR_EDITOR_LAYER_PATH, ATTR_EDITOR_MERGED_LAYERS, ATTR_TRANSFORM, AnyHash, BlendMode, CacheHash, CloneVarArgs, Color, Context, Ctx, ExtractAll, OwnedContextImpl};
+use glam::{DAffine2, DVec2};
+use graphic_types::graphic::{Graphic, IntoGraphicList};
+use graphic_types::{Artboard, Vector};
+use raster_types::{CPU, GPU, Raster};
+use vector_types::gradient::{GradientSpreadMethod, GradientType};
+use vector_types::{GradientStop, GradientStops, ReferencePoint};
+
+/// Returns the value at the specified index in the list.
+/// If no value exists at that index, the type's default value is returned.
+#[node_macro::node(category("General"))]
+pub fn index_elements<T: graphic_types::graphic::AtIndex + Clone + Default>(
+	_: impl Ctx,
+	/// The list of data.
+	#[implementations(
+		List<Artboard>,
+		List<Graphic>,
+		List<Vector>,
+		List<Raster<CPU>>,
+		List<Raster<GPU>>,
+		List<Color>,
+		List<GradientStops>,
+		List<String>,
+		List<f64>,
+		List<u8>,
+		List<NodeId>,
+	)]
+	list: T,
+	/// The index of the item to retrieve, starting from 0 for the first item. Negative indices count backwards from the end of the list, starting from -1 for the last item.
+	index: SignedInteger,
+) -> T::Output
+where
+	T::Output: Clone + Default,
+{
+	let index = index as i32;
+
+	if index < 0 { list.at_index_from_end(-index as usize) } else { list.at_index(index as usize) }.unwrap_or_default()
+}
+
+/// Returns the list with the element at the specified index removed.
+/// If no value exists at that index, the list is returned unchanged.
+#[node_macro::node(category("General"))]
+pub fn omit_element<T: graphic_types::graphic::OmitIndex + Clone + Default>(
+	_: impl Ctx,
+	/// The list of data.
+	#[implementations(
+		List<String>,
+		List<Artboard>,
+		List<Graphic>,
+		List<Vector>,
+		List<Raster<CPU>>,
+		List<Raster<GPU>>,
+		List<Color>,
+		List<GradientStops>,
+	)]
+	list: T,
+	/// The index of the item to remove, starting from 0 for the first item. Negative indices count backwards from the end of the list, starting from -1 for the last item.
+	index: SignedInteger,
+) -> T {
+	let index = index as i32;
+
+	if index < 0 {
+		list.omit_index_from_end(index.unsigned_abs() as usize)
+	} else {
+		list.omit_index(index as usize)
+	}
+}
+
+/// Returns the bare element (without the item's attributes) at the specified index in a `List`.
+/// Use this when downstream nodes want just the inner value rather than a `List` containing a single item.
+/// If no value exists at that index, the element type's default is returned.
+#[node_macro::node(category("General"))]
+pub fn extract_element<T: Clone + Default + Send + Sync + 'static>(
+	_: impl Ctx,
+	/// The `List` of data to extract from.
+	#[implementations(
+		List<String>,
+		List<f64>,
+		List<u8>,
+		List<NodeId>,
+		List<Color>,
+		List<GradientStops>,
+		List<Vector>,
+		List<Raster<CPU>>,
+		List<Graphic>,
+		List<Artboard>,
+	)]
+	list: List<T>,
+	/// The index of the item to retrieve, starting from 0 for the first item. Negative indices count backwards from the end of the list, starting from -1 for the last item.
+	index: SignedInteger,
+) -> T {
+	let len = list.len();
+	let index = index as i32;
+	let resolved = if index < 0 {
+		let from_end = index.unsigned_abs() as usize;
+		if from_end > len {
+			return T::default();
+		}
+		len - from_end
+	} else {
+		index as usize
+	};
+	list.element(resolved).cloned().unwrap_or_default()
+}
+
+#[node_macro::node(category("General"))]
+async fn map<Item: AnyHash + Send + Sync + CacheHash>(
+	ctx: impl Ctx + CloneVarArgs + ExtractAll,
+	#[implementations(
+		List<Graphic>,
+		List<Vector>,
+		List<Raster<CPU>>,
+		List<Color>,
+		List<GradientStops>,
+		List<String>,
+	)]
+	content: List<Item>,
+	#[implementations(
+		Context -> List<Graphic>,
+		Context -> List<Vector>,
+		Context -> List<Raster<CPU>>,
+		Context -> List<Color>,
+		Context -> List<GradientStops>,
+		Context -> List<String>,
+	)]
+	mapped: impl Node<Context<'static>, Output = List<Item>>,
+) -> List<Item> {
+	let mut rows = List::new();
+
+	for (i, row) in content.into_iter().enumerate() {
+		let owned_ctx = OwnedContextImpl::from(ctx.clone());
+		let owned_ctx = owned_ctx.with_vararg(Box::new(List::new_from_item(row))).with_index(i);
+		let list = mapped.eval(owned_ctx.into_context()).await;
+
+		rows.extend(list);
+	}
+
+	rows
+}
+
+#[node_macro::node(category("General"))]
+async fn mirror<T: 'n + Send + Clone>(
+	_: impl Ctx,
+	#[implementations(
+		List<Graphic>,
+		List<Vector>,
+		List<String>,
+		List<Raster<CPU>>,
+		List<Color>,
+		List<GradientStops>,
+	)]
+	content: List<T>,
+	#[default(ReferencePoint::Center)] relative_to_bounds: ReferencePoint,
+	#[unit(" px")] offset: f64,
+	#[range]
+	#[soft(-90..90)]
+	angle: Angle,
+	#[default(true)] keep_original: bool,
+) -> List<T>
+where
+	List<T>: BoundingBox,
+{
+	// Normalize the direction vector
+	let normal = DVec2::from_angle(angle.to_radians());
+
+	// The mirror reference may be based on the bounding box if an explicit reference point is chosen
+	let RenderBoundingBox::Rectangle(bounding_box) = content.bounding_box(DAffine2::IDENTITY, false) else {
+		return content;
+	};
+
+	let reference_point_location = relative_to_bounds.point_in_bounding_box((bounding_box[0], bounding_box[1]).into());
+	let mirror_reference_point = reference_point_location.map(|point| point + normal * offset);
+
+	// Create the reflection matrix
+	let reflection = DAffine2::from_mat2_translation(
+		glam::DMat2::from_cols(
+			DVec2::new(1. - 2. * normal.x * normal.x, -2. * normal.y * normal.x),
+			DVec2::new(-2. * normal.x * normal.y, 1. - 2. * normal.y * normal.y),
+		),
+		DVec2::ZERO,
+	);
+
+	// Apply reflection around the reference point
+	let reflected_transform = if let Some(mirror_reference_point) = mirror_reference_point {
+		DAffine2::from_translation(mirror_reference_point) * reflection * DAffine2::from_translation(-mirror_reference_point)
+	} else {
+		reflection * DAffine2::from_translation(DVec2::from_angle(angle.to_radians()) * DVec2::splat(-offset))
+	};
+
+	let mut result_list = List::new();
+
+	// Add original items depending on the keep_original flag
+	if keep_original {
+		for item in content.clone().into_iter() {
+			result_list.push(item);
+		}
+	}
+
+	// Create and add mirrored items
+	for mut row in content.into_iter() {
+		let current_transform: DAffine2 = row.attribute_cloned_or_default(ATTR_TRANSFORM);
+		row.set_attribute(ATTR_TRANSFORM, reflected_transform * current_transform);
+		result_list.push(row);
+	}
+
+	result_list
+}
+
+/// Returns the path identifying the subgraph (network) that contains this proto node — i.e. the input `node_path`
+/// with its own trailing entry dropped. The terminating element of the returned path is the document node whose
+/// encapsulated network we live in, so the path doubles as a unique reference to that node at any nesting depth.
+/// Used as the value source for stamping the `editor:layer_path` attribute on each item of a layer's output, which lets
+/// editor tools (e.g. selection, click target routing) trace data back to its owning layer regardless of whether
+/// the layer is at the root document network or nested inside a custom subgraph.
+#[node_macro::node(name("Path of Subgraph"), category(""))]
+pub fn path_of_subgraph(_: impl Ctx, node_path: List<NodeId>) -> List<NodeId> {
+	let len = node_path.len();
+	node_path.into_iter().take(len.saturating_sub(1)).collect()
+}
+
+/// Sets a named attribute on the input `List`, computing one value per item via the value-producing input. That input
+/// is evaluated once per item, with the item's index and the item itself (as a `List` containing only that item,
+/// passed as a vararg) provided via context, so the upstream pipeline can return a different value per item that may
+/// be derived from the item's own data. If the attribute already exists, its values are replaced; if not, it's added.
+/// The value is type-erased into an `AttributeValueDyn` by an auto-inserted convert node, so this node only
+/// monomorphizes over `T` instead of the cartesian product `(T, U)`.
+#[node_macro::node(category("Attributes: Write"))]
+async fn write_attribute<T: AnyHash + Clone + Send + Sync + CacheHash>(
+	ctx: impl ExtractAll + CloneVarArgs + Ctx,
+	/// The `List` to set the named attribute on (one value per item).
+	#[implementations(
+		List<Artboard>,
+		List<Graphic>,
+		List<Vector>,
+		List<Raster<CPU>>,
+		List<Color>,
+		List<GradientStops>,
+		List<f64>,
+		List<bool>,
+		List<String>,
+		List<DAffine2>,
+		List<BlendMode>,
+		List<GradientType>,
+		List<GradientSpreadMethod>,
+	)]
+	mut content: List<T>,
+	/// The attribute name (key) to write or replace.
+	name: String,
+	/// The node that produces the attribute value for each item. Called once per item with the item's index in context.
+	#[implementations(Context -> AttributeValueDyn)]
+	value: impl Node<'n, Context<'static>, Output = AttributeValueDyn>,
+) -> List<T> {
+	for index in 0..content.len() {
+		let row = content.clone_item(index).expect("index is within bounds");
+		let owned_ctx = OwnedContextImpl::from(ctx.clone()).with_vararg(Box::new(List::new_from_item(row))).with_index(index);
+		let v = value.eval(owned_ctx.into_context()).await;
+		content.set_attribute_value_dyn(&name, index, v);
+	}
+	content
+}
+
+/// Sets a named attribute on the primary list, with each value taken from the corresponding item's element in the source list (paired by index, wrapping if the source has fewer items).
+/// The source is type-erased into an `AttributeDyn` by an auto-inserted convert node, so this node only monomorphizes over `T` instead of the cartesian product `(T, U)`.
+#[node_macro::node(category("Attributes: Write"))]
+fn attach_attribute<T: AnyHash + Clone + Send + Sync + CacheHash>(
+	_: impl Ctx,
+	/// The `List` to attach the new attribute to.
+	#[implementations(
+		List<Artboard>,
+		List<Graphic>,
+		List<Vector>,
+		List<Raster<CPU>>,
+		List<Color>,
+		List<GradientStops>,
+		List<f64>,
+		List<bool>,
+		List<String>,
+		List<DAffine2>,
+		List<BlendMode>,
+		List<GradientType>,
+		List<GradientSpreadMethod>,
+	)]
+	mut content: List<T>,
+	/// The source values to attach.
+	#[expose]
+	source: AttributeDyn,
+	/// The name to assign to the new destination attribute.
+	name: String,
+) -> List<T> {
+	if source.is_empty() {
+		return content;
+	}
+	content.set_attribute_dyn(name, source);
+	content
+}
+
+/// Reads a named `Vector` attribute from the input list, outputting each value as an element of a new `Vector[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_vector(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<Vector> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<Vector>(&name, index) else { continue };
+		result.push(Item::new_from_element(value.clone()));
+	}
+	result
+}
+
+/// Reads a named numeric attribute (`f64`, `u64`, or `u32`) from the input list, outputting each value as an element of a new `f64[]`. Integer values are converted to `f64`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_number(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<f64> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let value = content
+			.attribute::<f64>(&name, index)
+			.copied()
+			.or_else(|| content.attribute::<u64>(&name, index).map(|v| *v as f64))
+			.or_else(|| content.attribute::<u32>(&name, index).map(|v| *v as f64));
+		let Some(value) = value else { continue };
+		result.push(Item::new_from_element(value));
+	}
+	result
+}
+
+/// Reads a named `bool` attribute from the input list, outputting each value as an element of a new `bool[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_bool(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<bool> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<bool>(&name, index) else { continue };
+		result.push(Item::new_from_element(*value));
+	}
+	result
+}
+
+/// Reads a named `String` attribute from the input list, outputting each value as an element of a new `String[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_string(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<String> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<String>(&name, index) else { continue };
+		result.push(Item::new_from_element(value.clone()));
+	}
+	result
+}
+
+/// Reads a named `DAffine2` transform attribute from the input list, outputting each value as an element of a new `DAffine2[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_transform(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<DAffine2> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<DAffine2>(&name, index) else { continue };
+		result.push(Item::new_from_element(*value));
+	}
+	result
+}
+
+/// Reads a named `Color` attribute from the input list, outputting each value as an element of a new `Color[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_color(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<Color> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<Color>(&name, index) else { continue };
+		result.push(Item::new_from_element(*value));
+	}
+	result
+}
+
+/// Reads a named `BlendMode` attribute from the input list, outputting each value as an element of a new `BlendMode[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_blend_mode(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<BlendMode> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<BlendMode>(&name, index) else { continue };
+		result.push(Item::new_from_element(*value));
+	}
+	result
+}
+
+/// Reads a named `GradientType` attribute from the input list, outputting each value as an element of a new `GradientType[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_gradient_type(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<GradientType> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<GradientType>(&name, index) else { continue };
+		result.push(Item::new_from_element(*value));
+	}
+	result
+}
+
+/// Reads a named `GradientSpreadMethod` attribute from the input list, outputting each value as an element of a new `GradientSpreadMethod[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_spread_method(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<GradientSpreadMethod> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<GradientSpreadMethod>(&name, index) else { continue };
+		result.push(Item::new_from_element(*value));
+	}
+	result
+}
+
+/// Reads a named `GradientStops` attribute from the input list, outputting each value as an element of a new `GradientStops[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_gradient_stops(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<GradientStops> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<GradientStops>(&name, index) else { continue };
+		result.push(Item::new_from_element(value.clone()));
+	}
+	result
+}
+
+/// Reads a named `Artboard` attribute from the input list, outputting each value as an element of a new `Artboard[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_artboard(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<Artboard> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<Artboard>(&name, index) else { continue };
+		result.push(Item::new_from_element(value.clone()));
+	}
+	result
+}
+
+/// Reads a named `Raster` attribute from the input list, outputting each value as an element of a new `Raster[]`.
+#[node_macro::node(category("Attributes: Read"))]
+fn read_attribute_raster(
+	_: impl Ctx,
+	content: ListDyn,
+	/// The attribute name (key) to read.
+	name: String,
+) -> List<Raster<CPU>> {
+	let mut result = List::with_capacity(content.len());
+	for index in 0..content.len() {
+		let Some(value) = content.attribute::<Raster<CPU>>(&name, index) else { continue };
+		result.push(Item::new_from_element(value.clone()));
+	}
+	result
+}
+
+/// Joins two `List`s of the same type, extending the base `List` with the items from the new `List`.
+#[node_macro::node(category("General"))]
+pub async fn extend<T: 'n + Send + Clone>(
+	_: impl Ctx,
+	/// The `List` whose items will appear at the start of the extended `List`.
+	#[implementations(List<Artboard>, List<Graphic>, List<Vector>, List<String>, List<Raster<CPU>>, List<Raster<GPU>>, List<Color>, List<GradientStops>)]
+	base: List<T>,
+	/// The `List` whose items will appear at the end of the extended `List`.
+	#[expose]
+	#[implementations(List<Artboard>, List<Graphic>, List<Vector>, List<String>, List<Raster<CPU>>, List<Raster<GPU>>, List<Color>, List<GradientStops>)]
+	new: List<T>,
+) -> List<T> {
+	let mut base = base;
+	base.extend(new);
+
+	base
+}
+
+// TODO: Eventually remove this document upgrade code
+/// Performs an obsolete function as part of a migration from an older document format.
+/// Users are advised to delete this node and replace it with a new one.
+#[node_macro::node(category(""))]
+pub async fn legacy_layer_extend<T: 'n + Send + Clone>(
+	_: impl Ctx,
+	#[implementations(List<Artboard>, List<Graphic>, List<Vector>, List<String>, List<Raster<CPU>>, List<Raster<GPU>>, List<Color>, List<GradientStops>)] base: List<T>,
+	#[expose]
+	#[implementations(List<Artboard>, List<Graphic>, List<Vector>, List<String>, List<Raster<CPU>>, List<Raster<GPU>>, List<Color>, List<GradientStops>)]
+	new: List<T>,
+	nested_node_path: List<NodeId>,
+) -> List<T> {
+	// Get the penultimate element of the node path, or None if the path is too short
+	// This is used to get the ID of the user-facing parent layer-style node (which encapsulates this internal node).
+	let layer = {
+		let index = nested_node_path.len().wrapping_sub(2);
+		nested_node_path.element(index).copied()
+	};
+
+	let mut base = base;
+	for mut row in new.into_iter() {
+		row.set_attribute(ATTR_EDITOR_LAYER_PATH, layer);
+		base.push(row);
+	}
+
+	base
+}
+
+/// Nests the input graphical content in a wrapper graphic. This essentially "groups" the input.
+/// The inverse of this node is 'Flatten Graphic'.
+#[node_macro::node(category("General"))]
+pub async fn wrap_graphic<T: Into<Graphic> + 'n>(
+	_: impl Ctx,
+	#[implementations(
+		List<Graphic>,
+	 	List<Vector>,
+		List<Raster<CPU>>,
+	 	List<Raster<GPU>>,
+	 	List<Color>,
+		List<GradientStops>,
+		List<String>,
+		DAffine2,
+		DVec2,
+	)]
+	content: T,
+) -> List<Graphic> {
+	List::new_from_element(content.into())
+}
+
+/// Converts a list of graphical content into a `Graphic[]` by placing it into an element of a new wrapper `Graphic[]`.
+/// If it is already a `Graphic[]`, it is not wrapped again. Use the 'Wrap Graphic' node if wrapping is always desired.
+#[node_macro::node(category("General"))]
+pub async fn to_graphic<T: IntoGraphicList>(
+	_: impl Ctx,
+	#[implementations(
+		List<Graphic>,
+		List<Vector>,
+		List<Raster<CPU>>,
+		List<Raster<GPU>>,
+		List<Color>,
+		List<GradientStops>,
+		List<String>,
+	)]
+	content: T,
+) -> List<Graphic> {
+	content.into_graphic_list()
+}
+
+/// Removes a level of nesting from a `Graphic[]`, or all nesting if "Fully Flatten" is enabled.
+#[node_macro::node(category("General"))]
+pub async fn flatten_graphic(_: impl Ctx, content: List<Graphic>, fully_flatten: bool) -> List<Graphic> {
+	// TODO: Avoid mutable reference, instead return a new List<Graphic>?
+	fn flatten_list(output_graphic_list: &mut List<Graphic>, current_graphic_list: List<Graphic>, fully_flatten: bool, recursion_depth: usize) {
+		for index in 0..current_graphic_list.len() {
+			let Some(current_element) = current_graphic_list.element(index) else { continue };
+			let current_element = current_element.clone();
+			let current_transform: DAffine2 = current_graphic_list.attribute_cloned_or_default(ATTR_TRANSFORM, index);
+
+			let recurse = fully_flatten || recursion_depth == 0;
+
+			match current_element {
+				// If we're allowed to recurse, flatten any graphics we encounter
+				Graphic::Graphic(mut current_element) if recurse => {
+					// Apply the parent graphic's transform to all child elements
+					for graphic_transform in current_element.iter_attribute_values_mut_or_default::<DAffine2>(ATTR_TRANSFORM) {
+						*graphic_transform = current_transform * *graphic_transform;
+					}
+
+					flatten_list(output_graphic_list, current_element, fully_flatten, recursion_depth + 1);
+				}
+				// Push any leaf elements we encounter: either `Graphic::Graphic(...)` values beyond the recursion depth, or non-`Graphic::Graphic` variants (e.g. `Graphic::Vector`, `Graphic::Raster*`, `Graphic::Color`, `Graphic::Gradient`, `Graphic::Text`)
+				_ => {
+					let attributes = current_graphic_list.clone_item_attributes(index);
+					output_graphic_list.push(Item::from_parts(current_element, attributes));
+				}
+			}
+		}
+	}
+
+	let mut output = List::new();
+	flatten_list(&mut output, content, fully_flatten, 0);
+
+	output
+}
+
+/// Converts a `Graphic[]` into a `Vector[]` by deeply flattening any vector content it contains, and discarding any non-vector content.
+#[node_macro::node(category("Vector"))]
+pub async fn flatten_vector<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<Vector>)] content: T) -> List<Vector> {
+	let graphic_list = content.into_graphic_list();
+	let mut output: List<Vector> = graphic_list.clone().into_flattened_list();
+
+	// TODO: Replace this snapshot hack with per-layer metadata driven by each layer's Monitor node.
+	// TODO: Flattening here erases the upstream `List<Graphic>` hierarchy that editor metadata collection walks
+	// TODO: to populate `upstream_footprints` / `local_transforms` / `click_targets` per child layer. As a workaround
+	// TODO: we stash the pre-flattened list on the output so `List<Vector>::collect_metadata` can recurse into it,
+	// TODO: which conflates render output with editor metadata and forces the pre-compensation dance below.
+	// TODO: The cleaner fix is to drive each layer's metadata from its own Monitor's captured `(Context, List<Graphic>)`,
+	// TODO: at which point this attribute (and the equivalents in Boolean Operation, Solidify Stroke, Flatten Path,
+	// TODO: Morph, Rasterize) become unnecessary.
+	if !output.is_empty() {
+		// Item 0 carries a composed transform inherited from the flattened input, but the merged_layers
+		// already holds the original transforms; pre-compensate by item 0's inverse so the renderer's
+		// `upstream_footprint *= item_0_transform` recursion cancels out and leaves the originals intact.
+		let mut graphic_list = graphic_list;
+		let item_0_transform: DAffine2 = output.attribute_cloned_or_default(ATTR_TRANSFORM, 0);
+		if item_0_transform.matrix2.determinant().abs() > f64::EPSILON {
+			let inverse = item_0_transform.inverse();
+			for transform in graphic_list.iter_attribute_values_mut_or_default::<DAffine2>(ATTR_TRANSFORM) {
+				*transform = inverse * *transform;
+			}
+		}
+
+		output.set_attribute(ATTR_EDITOR_MERGED_LAYERS, 0, graphic_list);
+	}
+
+	output
+}
+
+/// Converts a `Graphic[]` into a `Raster[]` by deeply flattening any raster content it contains, and discarding any non-raster content.
+#[node_macro::node(category("Raster"))]
+pub async fn flatten_raster<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<Raster<CPU>>)] content: T) -> List<Raster<CPU>> {
+	content.into_flattened_list()
+}
+
+/// Converts a `Graphic[]` into a `Color[]` by deeply flattening any color content it contains, and discarding any non-color content.
+#[node_macro::node(category("General"))]
+pub async fn flatten_color<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<Color>)] content: T) -> List<Color> {
+	content.into_flattened_list()
+}
+
+/// Converts a `Graphic[]` into a `GradientStops[]` by deeply flattening any gradient content it contains, and discarding any non-gradient content.
+#[node_macro::node(category("General"))]
+pub async fn flatten_gradient<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<GradientStops>)] content: T) -> List<GradientStops> {
+	content.into_flattened_list()
+}
+
+/// Constructs a gradient from a `Color[]`, where the colors are evenly distributed as gradient stops across the range from 0 to 1.
+#[node_macro::node(category("Color"))]
+fn colors_to_gradient<T: IntoGraphicList>(_: impl Ctx, #[implementations(List<Graphic>, List<Color>)] colors: T) -> List<GradientStops> {
+	let colors = colors.into_flattened_list::<Color>();
+	let total_colors = colors.len();
+
+	if total_colors == 0 {
+		return List::new_from_element(GradientStops::new(vec![
+			GradientStop {
+				position: 0.,
+				midpoint: 0.5,
+				color: Color::BLACK,
+			},
+			GradientStop {
+				position: 1.,
+				midpoint: 0.5,
+				color: Color::BLACK,
+			},
+		]));
+	}
+
+	if let (1, Some(&single_color)) = (total_colors, colors.element(0)) {
+		return List::new_from_element(GradientStops::new(vec![
+			GradientStop {
+				position: 0.,
+				midpoint: 0.5,
+				color: single_color,
+			},
+			GradientStop {
+				position: 1.,
+				midpoint: 0.5,
+				color: single_color,
+			},
+		]));
+	}
+
+	let colors = colors.into_iter().enumerate().map(|(index, row)| GradientStop {
+		position: index as f64 / (total_colors - 1) as f64,
+		midpoint: 0.5,
+		color: row.into_element(),
+	});
+	List::new_from_element(GradientStops::new(colors))
+}
@@ -0,0 +1,7 @@
+pub mod artboard;
+pub mod graphic;
+pub mod record;
+
+// Re-export all nodes
+pub use artboard::*;
+pub use graphic::*;
@@ -0,0 +1,970 @@
+//! Pilot record nodes over the production graphic types: element-space
+//! expanders whose ragged nesting lives inside `Graphic` values, ahead of the
+//! flip. Wiring is by hand until the compiler pass constructs layouts.
+
+use core_types::attribute::{Attr, Transform};
+use core_types::context::{DeriveCtx, ExtractIndex, IndexLink, InjectIndex};
+use core_types::extent::{ExtentIn, LevelIn, ListIn, ValueIn};
+use core_types::gpoll::{Extent, GPoll, GraphError, Interrupt};
+use core_types::{ATTR_TRANSFORM, Color, Ctx};
+use glam::DAffine2;
+use graphic_types::Vector;
+use graphic_types::graphic::Graphic;
+use raster_types::{CPU, Raster};
+use vector_types::{GradientStop, GradientStops};
+
+/// Whether the walk can descend into a group: the run holds `Graphic`
+/// elements.
+pub(crate) fn group_expands(group: &core_types::record::Group) -> bool {
+	group.content.typed_lanes::<Graphic>().is_some()
+}
+
+pub(crate) fn group_leaf_count(group: &core_types::record::Group, fully_flatten: bool, depth: usize) -> usize {
+	let lanes = group.content.typed_lanes::<Graphic>().expect("guarded by group_expands");
+	(0..lanes.len()).map(|lane| leaf_count(lanes.element_ref(lane), fully_flatten, depth + 1)).sum()
+}
+
+pub(crate) fn group_locate<'e>(group: &core_types::record::Group<'e>, transform: DAffine2, fully_flatten: bool, depth: usize, remaining: &mut usize) -> Option<(Graphic<'e>, DAffine2)> {
+	let item = &group.content;
+	let lanes = item.typed_lanes::<Graphic>().expect("guarded by group_expands");
+	let field = core_types::record::FieldOffset::<Transform>::of(item.layout(), 0);
+	(0..lanes.len()).find_map(|lane| {
+		let lane_transform = item.lanes().get(lane).attr_at(field);
+		locate(lanes.element_ref(lane), transform * lane_transform, fully_flatten, depth + 1, remaining)
+	})
+}
+
+/// Leaf rows a graphic expands to: its children's counts when the walk
+/// descends (top rows always, deeper groups only in a full flatten), one for
+/// itself otherwise.
+pub(crate) fn leaf_count(graphic: &Graphic, fully_flatten: bool, depth: usize) -> usize {
+	match graphic {
+		Graphic::Graphic(children) if fully_flatten || depth == 0 => (0..children.len())
+			.map(|index| children.element(index).map_or(0, |child| leaf_count(child, fully_flatten, depth + 1)))
+			.sum(),
+		Graphic::Group(group) if (fully_flatten || depth == 0) && group_expands(group) => group_leaf_count(group, fully_flatten, depth),
+		_ => 1,
+	}
+}
+
+/// The `remaining`-th leaf of `graphic` in walk order, with the transforms
+/// along its path composed onto `transform`.
+pub(crate) fn locate<'e>(graphic: &Graphic<'e>, transform: DAffine2, fully_flatten: bool, depth: usize, remaining: &mut usize) -> Option<(Graphic<'e>, DAffine2)> {
+	match graphic {
+		Graphic::Graphic(children) if fully_flatten || depth == 0 => (0..children.len()).find_map(|index| {
+			let child = children.element(index)?;
+			let child_transform: DAffine2 = children.attribute_cloned_or_default(ATTR_TRANSFORM, index);
+			locate(child, transform * child_transform, fully_flatten, depth + 1, remaining)
+		}),
+		Graphic::Group(group) if (fully_flatten || depth == 0) && group_expands(group) => group_locate(group, transform, fully_flatten, depth, remaining),
+		_ if *remaining == 0 => Some((graphic.clone(), transform)),
+		_ => {
+			*remaining -= 1;
+			None
+		}
+	}
+}
+
+/// Rank-model Flatten: one flat level holding the content's leaves, each with
+/// the transforms along its path composed; a group beyond the walk's depth
+/// rides as a leaf with its embedded transforms untouched.
+#[node_macro::node(category("Test"), extent(flatten_extent))]
+fn flatten(ctx: impl Ctx + ExtractIndex + InjectIndex + Copy, content: IList<Graphic<'static>>, fully_flatten: bool) -> Result<IList<(Graphic<'static>, Attr<Transform>)>, Interrupt> {
+	let mut remaining = ctx.index() as usize;
+	for row in 0..content.len() {
+		let graphic = content.element_ref(row);
+		let count = leaf_count(graphic, fully_flatten, 0);
+		if remaining >= count {
+			remaining -= count;
+			continue;
+		}
+		let transform: DAffine2 = content.lane(row).attr::<Transform>();
+		if let Some((leaf, composed)) = locate(graphic, transform, fully_flatten, 0, &mut remaining) {
+			return Ok((leaf, Attr(composed)));
+		}
+	}
+	Err(GraphError::new("flatten addressed past its leaf count").into())
+}
+
+/// The level holds one row per leaf of the walk.
+fn flatten_extent(content: ListIn<'_, Graphic>, fully_flatten: ValueIn<'_, bool>, level: LevelIn) -> GPoll<Extent> {
+	match level.top() {
+		true => fully_flatten
+			.get()
+			.zip(content.get())
+			.map(|(fully_flatten, content)| Extent::Exactly((0..content.len()).map(|row| leaf_count(content.element_ref(row), fully_flatten, 0)).sum())),
+		false => GPoll::Final(Extent::Exactly(1)),
+	}
+}
+
+/// Rank-model Wrap: the content level as one group element on a one-lane
+/// level, the inverse of flatten's one-level descent.
+#[node_macro::node(category("Test"), extent(wrap_extent))]
+fn wrap<'e>(_: impl Ctx, content: IList<Graphic<'e>>) -> Result<IList<Graphic<'e>>, Interrupt> {
+	let item = content.as_group_item();
+	Ok(Graphic::Group(core_types::record::Group { row: None, content: item }))
+}
+
+/// The collected group is the level's single lane.
+fn wrap_extent(_content: ListIn<'_, Graphic>, _level: LevelIn) -> GPoll<Extent> {
+	GPoll::Final(Extent::Exactly(1))
+}
+
+/// Rank-model colors-to-gradient: the color level folds into one gradient
+/// with evenly spaced stops.
+#[node_macro::node(category("Test"))]
+fn to_gradient(_: impl Ctx, colors: IList<Color>) -> GradientStops {
+	let stop = |position: f64, color: Color| GradientStop { position, midpoint: 0.5, color };
+	match colors.len() {
+		0 => GradientStops::new(vec![stop(0., Color::BLACK), stop(1., Color::BLACK)]),
+		1 => GradientStops::new(vec![stop(0., colors.get(0)), stop(1., colors.get(0))]),
+		total => GradientStops::new((0..total).map(|index| stop(index as f64 / (total - 1) as f64, colors.get(index)))),
+	}
+}
+
+/// One content row as the production vararg shape: a single-item legacy list
+/// carrying the row's element only, so the list's dyn-hash is a complete
+/// cache key over the observables.
+pub(crate) fn vararg_row<Row: Clone + Send + Sync + 'static>(content: core_types::node::List<'_, Row>, row: usize) -> core_types::list::List<Row> {
+	core_types::list::List::new_from_element(content.element_ref(row).clone())
+}
+
+/// Rank-model Map: one subgraph invocation per content row, the row riding as
+/// a vararg; the subgraph's own level nests under the content level. The
+/// levels report a lower bound; consumers drain to the past-end signal.
+#[node_macro::node(category("Test"))]
+fn map<Row: Clone + Send + Sync + core_types::CacheHash + 'static, T>(
+	ctx: impl Ctx + DeriveCtx + ExtractIndex + InjectIndex + Copy,
+	#[implementations(Graphic, Vector, Raster<CPU>, Color, GradientStops, String)] content: IList<Row>,
+	mapped: impl Node<Context<'_>, Output = IList<T>>,
+) -> Result<IList<IList<T>>, Interrupt> {
+	let mut remaining = ctx.index();
+	for row in 0..content.len() {
+		let item = vararg_row(content, row);
+		let scoped = ctx.push_vararg(&item);
+		let lanes = mapped.inner_extent_at(&scoped.ctx(), row as u64)?;
+		if remaining >= lanes {
+			remaining -= lanes;
+			continue;
+		}
+		let mut frame = IndexLink { index: 0, outer: None };
+		return mapped.eval(&scoped.ctx().push_level(&mut frame, row as u64, remaining));
+	}
+	Err(GraphError::past_end().into())
+}
+
+/// Rank-model flat-map (the production Map): map's walk with the subgraph's
+/// lanes concatenated into one flat level. The level reports a lower bound;
+/// consumers drain to the past-end signal.
+#[node_macro::node(category("Test"))]
+fn flat_map<Row: Clone + Send + Sync + core_types::CacheHash + 'static, T>(
+	ctx: impl Ctx + DeriveCtx + ExtractIndex + InjectIndex + Copy,
+	#[implementations(Graphic, Vector, Raster<CPU>, Color, GradientStops, String)] content: IList<Row>,
+	mapped: impl Node<Context<'_>, Output = IList<T>>,
+) -> Result<IList<T>, Interrupt> {
+	let mut remaining = ctx.index();
+	for row in 0..content.len() {
+		let item = vararg_row(content, row);
+		let scoped = ctx.push_vararg(&item);
+		let lanes = mapped.inner_extent_at(&scoped.ctx(), row as u64)?;
+		if remaining >= lanes {
+			remaining -= lanes;
+			continue;
+		}
+		let mut frame = IndexLink { index: 0, outer: None };
+		return mapped.eval(&scoped.ctx().push_level(&mut frame, row as u64, remaining));
+	}
+	Err(GraphError::past_end().into())
+}
+
+/// Rank-model level collapse: two nested levels become one flat level. The
+/// flat index already spans the input's depth, so the eval forwards it.
+#[node_macro::node(category("Test"), extent(flatten_levels_extent))]
+fn flatten_levels<T>(ctx: impl Ctx + DeriveCtx + ExtractIndex, content: impl Node<Context<'_>, Output = IList<IList<T>>>) -> Result<IList<T>, Interrupt> {
+	let head = ctx.index_head();
+	content.eval(&ctx.promoted(&head, ctx.index()))
+}
+
+/// The collapsed level's extent is the sum of the inner extents across the
+/// outer copies; the product composite cannot express a ragged total. A
+/// lower-bound level keeps the sum a lower bound.
+fn flatten_levels_extent(content: ExtentIn<'_>, level: LevelIn) -> GPoll<Extent> {
+	match level.top() {
+		true => {
+			let outer = match content.at_copy(0, LevelIn { level: 1, depth: 2 }) {
+				GPoll::Final(Extent::Exactly(outer)) => outer,
+				GPoll::Final(Extent::AtLeast(bound)) => return GPoll::Final(Extent::AtLeast(bound)),
+				GPoll::Final(Extent::Free) => return GPoll::error("flatten over an unbounded outer level"),
+				other => return other,
+			};
+			let mut total = 0;
+			for copy in 0..outer {
+				match content.at_copy(copy as u64, LevelIn { level: 0, depth: 2 }) {
+					GPoll::Final(Extent::Exactly(count)) => total += count,
+					GPoll::Final(Extent::AtLeast(count)) => return GPoll::Final(Extent::AtLeast(total + count)),
+					GPoll::Final(Extent::Free) => return GPoll::error("flatten over an unbounded inner level"),
+					other => return other,
+				}
+			}
+			GPoll::Final(Extent::Exactly(total))
+		}
+		false => GPoll::Final(Extent::Exactly(1)),
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use core_types::SourceId;
+	use core_types::arena::Arena;
+	use core_types::attribute::Attribute as AttributeMarker;
+	use core_types::context::{ContextImpl, EvalScope, ExtractArena};
+	use core_types::list::{Item, List};
+	use core_types::node::Node;
+	use core_types::record::{self, FrameClaim, Layout, RecordSource, Served};
+	use core_types::value::ValueSource;
+
+	struct GraphicSource {
+		layout: Layout,
+		rows: Vec<(Graphic<'static>, DAffine2)>,
+	}
+
+	impl<C: ExtractIndex> Node<C> for GraphicSource {
+		fn serve<'e, 'l>(&self, input: &C, slot: FrameClaim<'e, 'l>) -> GPoll<Served<'e>>
+		where
+			C: ExtractArena<ArenaRef = &'e Arena>,
+		{
+			let (graphic, transform) = &self.rows[input.innermost_index() as usize % self.rows.len()];
+			let mut frame = slot;
+			let arena = ExtractArena::arena(input);
+			if frame.element(graphic.clone(), arena).is_none() {
+				return GPoll::arena_exhausted();
+			}
+			write_attr_at::<Transform>(&mut frame, &self.layout, *transform);
+			// SAFETY: the writes above complete the record of this layout.
+			GPoll::Final(unsafe { frame.finish_served() })
+		}
+
+		fn extent_at<'x>(&self, _input: &C, _level: u8, _frames: &core_types::record::Frames<'x>) -> GPoll<Extent>
+		where
+			C: ExtractArena<ArenaRef = &'x Arena>,
+		{
+			GPoll::Final(Extent::Exactly(self.rows.len()))
+		}
+
+		fn layout(&self) -> &Layout {
+			&self.layout
+		}
+	}
+
+	/// Writes a field at the layout's resolved offset, the wiring-proven pairing
+	/// a generated node performs.
+	fn write_field_at<T: Copy + 'static>(frame: &mut FrameClaim<'_, '_>, layout: &Layout, name: &str, level: u8, value: T) {
+		let field = layout
+			.fields
+			.iter()
+			.find(|field| field.name == name && field.level == level)
+			.expect("the layout carries the written field");
+		assert_eq!(field.type_id, std::any::TypeId::of::<T>(), "the field was declared at this value type");
+		// SAFETY: the offset is this layout's own, at the field's declared type.
+		unsafe { frame.attr_at(field.offset, value) };
+	}
+
+	/// [`write_field_at`] for a census marker at level 0.
+	fn write_attr_at<A: core_types::attribute::Attribute>(frame: &mut FrameClaim<'_, '_>, layout: &Layout, value: A::Value<'static>)
+	where
+		A::Value<'static>: Copy + 'static,
+	{
+		write_field_at(frame, layout, A::NAME, 0, value);
+	}
+	fn scope_fixture<'a>(generations: &'a [(SourceId, u64)], arena: &'a Arena) -> EvalScope<'a> {
+		EvalScope::new(Some(0.5), None, None, generations, arena)
+	}
+
+	fn install<N: Node<ContextImpl<'static>>>(mut node: N, meta: record::LayoutMeta, inputs: &[Option<&Layout>]) -> N {
+		// The fixtures wire constants into every eager input, which the compiler
+		// pass records as lane-invariant.
+		let resolved = record::RecordLayout {
+			lane_invariant: u32::MAX,
+			..meta.resolve(inputs)
+		};
+		<N as Node<ContextImpl<'static>>>::set_layout(&mut node, resolved);
+		node
+	}
+
+	fn install_flip<N: Node<ContextImpl<'static>>>(mut node: N, layout: &Layout) -> N {
+		let bundle = record::RecordLayout {
+			frame_bytes: layout.frame_bytes(),
+			plan: Vec::new(),
+			layout: layout.clone(),
+			lane_invariant: u32::MAX,
+		};
+		<N as Node<ContextImpl<'static>>>::set_layout(&mut node, bundle);
+		node
+	}
+
+	fn graphic_layout() -> Layout {
+		Layout::default().with_writes(1, record::element_write_hashed::<Graphic>(), &[record::FieldWrite::of::<Transform>(0)])
+	}
+
+	fn text(label: &str) -> Graphic<'static> {
+		Graphic::Text(label.to_string())
+	}
+
+	fn group(children: Vec<(Graphic<'static>, DAffine2)>) -> Graphic<'static> {
+		let mut list = List::new();
+		for (index, (child, transform)) in children.into_iter().enumerate() {
+			list.push(Item::new_from_element(child));
+			list.set_attribute(ATTR_TRANSFORM, index, transform);
+		}
+		Graphic::Graphic(list)
+	}
+
+	fn text_of<'a>(graphic: &'a Graphic<'_>) -> &'a str {
+		let Graphic::Text(text) = graphic else {
+			panic!("expected a text leaf, got {graphic:?}");
+		};
+		text
+	}
+
+	fn translation(x: f64) -> DAffine2 {
+		DAffine2::from_translation(glam::DVec2::new(x, 0.))
+	}
+
+	/// [a, G[b, H[c]]] with translations picked so each composed path is a
+	/// distinct sum.
+	fn fixture_rows() -> Vec<(Graphic<'static>, DAffine2)> {
+		vec![
+			(text("a"), translation(1.)),
+			(
+				group(vec![(text("b"), translation(20.)), (group(vec![(text("c"), translation(300.))]), translation(4000.))]),
+				translation(0.5),
+			),
+		]
+	}
+
+	macro_rules! build {
+		($layout:ident, $rows:expr, $fully:expr) => {
+			install(
+				FlattenNode::new(
+					RecordSource::new(
+						GraphicSource {
+							layout: $layout.clone(),
+							rows: $rows,
+						},
+						&$layout,
+						&$layout,
+					),
+					ValueSource::new($fully),
+				),
+				flatten_layout_meta(),
+				&[Some(&$layout)],
+			)
+		};
+	}
+
+	/// A subgraph source deriving its rows from the vararg: a `Text` row of
+	/// string `s` expands to `s.len()` lanes labeled `s{k}`, each translated
+	/// by `k`. The vararg is attr-less, so the content rows' transforms must
+	/// not reach these lanes.
+	struct PerRowSource {
+		layout: Layout,
+	}
+
+	fn vararg_text<C: core_types::ExtractVarArgs>(input: &C) -> Option<String> {
+		let arg = core_types::ExtractVarArgs::vararg(input, 0).ok()?;
+		let list = arg.downcast_ref::<core_types::list::List<Graphic>>()?;
+		let Graphic::Text(text) = list.element(0)? else { return None };
+		Some(text.clone())
+	}
+
+	impl<C: ExtractIndex + core_types::ExtractVarArgs> Node<C> for PerRowSource {
+		fn serve<'e, 'l>(&self, input: &C, slot: FrameClaim<'e, 'l>) -> GPoll<Served<'e>>
+		where
+			C: ExtractArena<ArenaRef = &'e Arena>,
+		{
+			let Some(label) = vararg_text(input) else {
+				return GPoll::error("the subgraph fixture expects a text vararg");
+			};
+			let lane = input.innermost_index();
+			let graphic = text(&format!("{label}{lane}"));
+			let translated = DAffine2::from_translation(glam::DVec2::new(lane as f64, 0.));
+			let mut frame = slot;
+			let arena = ExtractArena::arena(input);
+			if frame.element(graphic, arena).is_none() {
+				return GPoll::arena_exhausted();
+			}
+			write_attr_at::<Transform>(&mut frame, &self.layout, translated);
+			// SAFETY: the writes above complete the record of this layout.
+			GPoll::Final(unsafe { frame.finish_served() })
+		}
+
+		fn extent_at<'x>(&self, input: &C, _level: u8, _frames: &core_types::record::Frames<'x>) -> GPoll<Extent>
+		where
+			C: ExtractArena<ArenaRef = &'x Arena>,
+		{
+			match vararg_text(input) {
+				Some(label) => GPoll::Final(Extent::Exactly(label.len())),
+				None => GPoll::error("the subgraph fixture expects a text vararg"),
+			}
+		}
+
+		fn layout(&self) -> &Layout {
+			&self.layout
+		}
+	}
+
+	fn ragged_rows() -> Vec<(Graphic<'static>, DAffine2)> {
+		vec![(text("ab"), translation(10.)), (text("xyz"), translation(20.))]
+	}
+
+	fn routing_meta(source: u8, level_delta: i8) -> record::LayoutMeta {
+		record::LayoutMeta {
+			sources: vec![source],
+			reads: vec![],
+			element: record::ElementSpec::Carried,
+			writes: vec![],
+			removes: vec![],
+			level_delta,
+			folded: None,
+		}
+	}
+
+	const RAGGED_FLAT: [(&str, f64); 5] = [("ab0", 0.), ("ab1", 1.), ("xyz0", 0.), ("xyz1", 1.), ("xyz2", 2.)];
+
+	#[test]
+	fn map_scans_ragged_rows() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let layout = graphic_layout();
+		let node = install(
+			MapNode::<_, _, Graphic>::new(
+				RecordSource::new(
+					GraphicSource {
+						layout: layout.clone(),
+						rows: ragged_rows(),
+					},
+					&layout,
+					&layout,
+				),
+				PerRowSource { layout: layout.clone() },
+				&layout,
+			),
+			routing_meta(1, 1),
+			&[Some(&layout), Some(&layout)],
+		);
+		let out = Node::<ContextImpl>::layout(&node).clone();
+		assert_eq!(out.depth, 2);
+		// The extent-fn-less levels report a lower bound; addressing below
+		// proves the lanes are all reachable regardless.
+		assert_eq!(node.extent_at(&ctx, 1, &frames.reborrow()), GPoll::Final(Extent::AtLeast(0)));
+		assert_eq!(node.extent_at(&ctx, 0, &frames.reborrow()), GPoll::Final(Extent::AtLeast(0)));
+
+		let head = ctx.index_head();
+		for (lane, &(label, x)) in RAGGED_FLAT.iter().enumerate() {
+			let GPoll::Final(record) = record::capture(&node, &ctx.promoted(&head, lane as u64), &frames) else {
+				panic!("expected a final record");
+			};
+			assert_eq!(text_of(&record.element::<Graphic>()), label, "lane {lane}");
+			let transform: DAffine2 = record.attr::<Transform>();
+			assert_eq!(transform.translation.x, x, "lane {lane}");
+		}
+	}
+
+	#[test]
+	fn flat_map_matches_flatten_of_map() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let layout = graphic_layout();
+		let flat = install(
+			FlatMapNode::<_, _, Graphic>::new(
+				RecordSource::new(
+					GraphicSource {
+						layout: layout.clone(),
+						rows: ragged_rows(),
+					},
+					&layout,
+					&layout,
+				),
+				PerRowSource { layout: layout.clone() },
+				&layout,
+			),
+			routing_meta(1, 0),
+			&[Some(&layout), Some(&layout)],
+		);
+		let mapped = install(
+			MapNode::<_, _, Graphic>::new(
+				RecordSource::new(
+					GraphicSource {
+						layout: layout.clone(),
+						rows: ragged_rows(),
+					},
+					&layout,
+					&layout,
+				),
+				PerRowSource { layout: layout.clone() },
+				&layout,
+			),
+			routing_meta(1, 1),
+			&[Some(&layout), Some(&layout)],
+		);
+		let map_out = Node::<ContextImpl>::layout(&mapped).clone();
+		let composed = install(FlattenLevelsNode::new(mapped, &map_out), routing_meta(0, -1), &[Some(&map_out)]);
+
+		let flat_out = Node::<ContextImpl>::layout(&flat).clone();
+		let composed_out = Node::<ContextImpl>::layout(&composed).clone();
+		assert_eq!(flat_out.depth, 1);
+		assert_eq!(composed_out.depth, 1);
+		// Both spellings report the same lower bound; the lane loop below is
+		// the law.
+		assert_eq!(flat.extent_at(&ctx, 0, &frames.reborrow()), GPoll::Final(Extent::AtLeast(0)));
+		assert_eq!(composed.extent_at(&ctx, 0, &frames.reborrow()), GPoll::Final(Extent::AtLeast(0)));
+
+		let head = ctx.index_head();
+		for (lane, &(label, x)) in RAGGED_FLAT.iter().enumerate() {
+			let scoped = ctx.promoted(&head, lane as u64);
+			let GPoll::Final(direct) = record::capture(&flat, &scoped, &frames) else {
+				panic!("expected a final record from flat_map");
+			};
+			let direct_label = text_of(&direct.element::<Graphic>()).to_string();
+			let direct_x: DAffine2 = direct.attr::<Transform>();
+			let GPoll::Final(value) = record::capture(&composed, &scoped, &frames) else {
+				panic!("expected a final record from flatten(map)");
+			};
+			assert_eq!(text_of(&value.element::<Graphic>()), direct_label, "lane {lane}");
+			let composed_x: DAffine2 = value.attr::<Transform>();
+			assert_eq!(composed_x, direct_x, "lane {lane}");
+			assert_eq!((direct_label.as_str(), direct_x.translation.x), (label, x), "lane {lane}");
+		}
+	}
+
+	#[test]
+	fn flat_map_registers_one_row_per_content_type() {
+		let entries = _flat_map_mod::flat_map_entries();
+		assert_eq!(entries.len(), 6, "one registry row per content implementation");
+		let content_types: Vec<core_types::Type> = entries.iter().map(|entry| entry.io.inputs[0].clone()).collect();
+		assert_eq!(content_types[0], core_types::registry::record_source_type::<Graphic>());
+		assert_eq!(content_types[1], core_types::registry::record_source_type::<Vector>());
+		assert_eq!(content_types[5], core_types::registry::record_source_type::<String>());
+		// The subject and the output stay erased across rows.
+		assert_eq!(entries[0].io.inputs[1], entries[5].io.inputs[1]);
+		assert_eq!(entries[0].io.return_value, entries[5].io.return_value);
+	}
+
+	#[test]
+	fn flat_map_batch_matches_per_lane_eval() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let layout = graphic_layout();
+		let node = install(
+			FlatMapNode::<_, _, Graphic>::new(
+				RecordSource::new(
+					GraphicSource {
+						layout: layout.clone(),
+						rows: ragged_rows(),
+					},
+					&layout,
+					&layout,
+				),
+				PerRowSource { layout: layout.clone() },
+				&layout,
+			),
+			routing_meta(1, 0),
+			&[Some(&layout), Some(&layout)],
+		);
+		let out = Node::<ContextImpl>::layout(&node).clone();
+		let head = ctx.index_head();
+		let scoped = ctx.promoted(&head, 0);
+
+		let mut scratch = vec![std::mem::MaybeUninit::<u64>::uninit(); 5 * out.lane_stride() / 8];
+		let core_types::node::BatchStatus::Filled(batch, ..) = node.eval_batch(&scoped, 0..5, Some(&mut scratch), &frames) else {
+			panic!("expected a filled batch");
+		};
+		let batch = batch.into_shared();
+		assert_eq!(batch.len(), 5);
+		let offset = out.offset_of(<Transform as AttributeMarker>::NAME, 0).unwrap();
+		for lane in 0..5 {
+			let GPoll::Final(record) = record::capture(&node, &ctx.promoted(&head, lane as u64), &frames) else {
+				panic!("expected a final record");
+			};
+			let single = text_of(&record.element::<Graphic>()).to_string();
+			assert_eq!(text_of(unsafe { record::borrow_element::<Graphic>(batch.get(lane).rec()) }), single, "lane {lane}");
+			let batched: DAffine2 = unsafe { batch.get(lane).rec().read(offset) };
+			let direct: DAffine2 = record.attr::<Transform>();
+			assert_eq!(batched, direct, "lane {lane}");
+		}
+	}
+
+	#[test]
+	fn flatten_expands_one_level() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let layout = graphic_layout();
+		let node = build!(layout, fixture_rows(), false);
+		let out = Node::<ContextImpl>::layout(&node).clone();
+		assert_eq!(out.depth, 1);
+		assert_eq!(node.extent_at(&ctx, 0, &frames.reborrow()), GPoll::Final(Extent::Exactly(3)));
+
+		let head = ctx.index_head();
+		// Lane 2 is the unexpanded subgroup H, riding as a leaf at G's depth.
+		let expected: [(&str, f64); 2] = [("a", 1.), ("b", 20.5)];
+		for (lane, &(label, x)) in expected.iter().enumerate() {
+			let GPoll::Final(record) = record::capture(&node, &ctx.promoted(&head, lane as u64), &frames) else {
+				panic!("expected a final record");
+			};
+			assert_eq!(text_of(&record.element::<Graphic>()), label, "lane {lane}");
+			let transform: DAffine2 = record.attr::<Transform>();
+			assert_eq!(transform.translation.x, x, "lane {lane}");
+		}
+
+		let GPoll::Final(record) = record::capture(&node, &ctx.promoted(&head, 2), &frames) else {
+			panic!("expected a final record");
+		};
+		let Graphic::Graphic(children) = record.element::<Graphic>() else {
+			panic!("lane 2 keeps the subgroup element");
+		};
+		assert_eq!(children.len(), 1);
+		assert_eq!(text_of(children.element(0).unwrap()), "c");
+		assert_eq!(
+			children.attribute_cloned_or_default::<DAffine2>(ATTR_TRANSFORM, 0).translation.x,
+			300.,
+			"embedded transforms ride untouched"
+		);
+		let transform: DAffine2 = record.attr::<Transform>();
+		assert_eq!(transform.translation.x, 4000.5);
+	}
+
+	#[test]
+	fn a_wire_materializes_into_a_group_for_the_renderer() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let source = core_types::value::LeveledValueSource::new(vec![text("a"), text("b")]);
+		match graphic_types::boundary::materialize_group(&source, &ctx, &arena, &frames) {
+			graphic_types::boundary::LevelGroup::Group(group, _) => {
+				let list = graphic_types::graphic::group_to_legacy_list(&group);
+				assert_eq!(list.len(), 2);
+			}
+			_ => panic!("expected a materialized group"),
+		}
+	}
+
+	#[test]
+	fn a_level_batch_converts_to_its_legacy_list() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let source = core_types::value::LeveledValueSource::new(vec![1.5f64, 2.5]);
+		let layout = Node::<ContextImpl>::layout(&source).clone();
+		let record::LevelStatus::Batch(batch, _) = record::materialize_level(&source, &ctx, &arena, &frames) else {
+			panic!("expected a batch");
+		};
+		let legacy = graphic_types::boundary::batch_to_legacy(&layout, batch, &arena).expect("f64 is in the legacy vocabulary");
+		let list = legacy.downcast_ref::<List<f64>>().unwrap();
+		assert_eq!(list.len(), 2);
+		assert_eq!(list.element(0).copied(), Some(1.5));
+		assert_eq!(list.element(1).copied(), Some(2.5));
+	}
+
+	#[test]
+	fn wrap_collects_the_level_into_a_group() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let layout = graphic_layout();
+		let rows = vec![(text("a"), translation(1.)), (text("b"), translation(2.))];
+		let node = install(
+			WrapNode::new(RecordSource::new(GraphicSource { layout: layout.clone(), rows }, &layout, &layout), &layout),
+			wrap_layout_meta(),
+			&[Some(&layout)],
+		);
+		let out = Node::<ContextImpl>::layout(&node).clone();
+		assert_eq!(out.depth, 1);
+		assert_eq!(node.extent_at(&ctx, 0, &frames.reborrow()), GPoll::Final(Extent::Exactly(1)), "the group is the level's single lane");
+
+		let head = ctx.index_head();
+		let GPoll::Final(value) = record::serve_input(&node, &ctx.promoted(&head, 0), &frames) else {
+			panic!("expected a final record");
+		};
+		let Graphic::Group(group) = (unsafe { record::borrow_element::<Graphic>(out.rec(&value)) }) else {
+			panic!("expected a group element");
+		};
+		assert!(group.row.is_none());
+		let item = &group.content;
+		assert_eq!(item.len(), 2);
+		let lanes = item.typed_lanes::<Graphic>().expect("the run holds the adopted graphic lanes");
+		let offset = item.layout().offset_of(ATTR_TRANSFORM, 0).unwrap();
+		for (lane, (label, x)) in [("a", 1.), ("b", 2.)].into_iter().enumerate() {
+			assert_eq!(text_of(lanes.element_ref(lane)), label, "lane {lane}");
+			let transform: DAffine2 = unsafe { item.lanes().get(lane).rec().read(offset) };
+			assert_eq!(transform.translation.x, x, "lane {lane}");
+		}
+	}
+
+	#[test]
+	fn a_group_element_deep_copies_to_its_owned_form_and_replays() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let layout = graphic_layout();
+		let rows = vec![(text("a"), translation(1.)), (text("b"), translation(2.))];
+		let node = install(
+			WrapNode::new(RecordSource::new(GraphicSource { layout: layout.clone(), rows }, &layout, &layout), &layout),
+			wrap_layout_meta(),
+			&[Some(&layout)],
+		);
+		let out = Node::<ContextImpl>::layout(&node).clone();
+
+		let head = ctx.index_head();
+		let GPoll::Final(value) = record::serve_input(&node, &ctx.promoted(&head, 0), &frames) else {
+			panic!("expected a final record");
+		};
+		let copy = unsafe { (out.element.clone_out)(out.rec(&value).ptr()) };
+
+		let replay_arena = Arena::new(1 << 16).unwrap();
+		// Word storage: a parked element slot holds an 8-aligned reference.
+		let mut slot = [0u64; 1];
+		unsafe { (out.element.repark)(&*copy, slot.as_mut_ptr().cast(), &replay_arena) }.expect("the arena holds the replay");
+		// SAFETY: the re-park wrote a parked `Graphic` element into `slot`.
+		let Graphic::Group(group) = (unsafe { record::borrow_element::<Graphic>(record::Rec::new(slot.as_ptr().cast())) }) else {
+			panic!("the replay restores the group element");
+		};
+		let item = &group.content;
+		assert_eq!(item.len(), 2);
+		let lanes = item.typed_lanes::<Graphic>().expect("the run holds the adopted graphic lanes");
+		let offset = item.layout().offset_of(ATTR_TRANSFORM, 0).unwrap();
+		for (lane, (label, x)) in [("a", 1.), ("b", 2.)].into_iter().enumerate() {
+			assert_eq!(text_of(lanes.element_ref(lane)), label, "lane {lane}");
+			let transform: DAffine2 = unsafe { item.lanes().get(lane).rec().read(offset) };
+			assert_eq!(transform.translation.x, x, "lane {lane}");
+		}
+	}
+
+	#[test]
+	fn colors_fold_into_evenly_spaced_stops() {
+		let frames = core_types::record::test_frames(1 << 16);
+		struct ColorSource {
+			layout: Layout,
+			colors: Vec<Color>,
+		}
+
+		impl<C: ExtractIndex> Node<C> for ColorSource {
+			fn serve<'e, 'l>(&self, input: &C, slot: FrameClaim<'e, 'l>) -> GPoll<Served<'e>>
+			where
+				C: ExtractArena<ArenaRef = &'e Arena>,
+			{
+				let color = self.colors[input.innermost_index() as usize];
+				let mut frame = slot;
+				let arena = ExtractArena::arena(input);
+				if frame.element(color, arena).is_none() {
+					return GPoll::arena_exhausted();
+				}
+				// SAFETY: the writes above complete the record of this layout.
+				GPoll::Final(unsafe { frame.finish_served() })
+			}
+
+			fn extent_at<'x>(&self, _input: &C, _level: u8, _frames: &core_types::record::Frames<'x>) -> GPoll<Extent>
+			where
+				C: ExtractArena<ArenaRef = &'x Arena>,
+			{
+				GPoll::Final(Extent::Exactly(self.colors.len()))
+			}
+
+			fn layout(&self) -> &Layout {
+				&self.layout
+			}
+		}
+
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let layout = Layout::default().with_writes(1, record::element_write_hashed::<Color>(), &[]);
+		let out = Layout::default().with_writes(0, record::element_write_hashed::<GradientStops>(), &[]);
+		let build = |colors: Vec<Color>| install_flip(ToGradientNode::new(RecordSource::new(ColorSource { layout: layout.clone(), colors }, &layout, &layout), &layout), &out);
+		let stops_of = |colors: Vec<Color>| {
+			let node = build(colors);
+			let GPoll::Final(record) = record::capture(&node, &ctx, &frames) else {
+				panic!("expected a final record");
+			};
+			record.element::<GradientStops>()
+		};
+
+		let three = stops_of(vec![Color::BLACK, Color::WHITE, Color::BLACK]);
+		assert_eq!(three.iter().map(|stop| stop.position).collect::<Vec<_>>(), vec![0., 0.5, 1.]);
+		assert_eq!(three.iter().map(|stop| stop.color).collect::<Vec<_>>(), vec![Color::BLACK, Color::WHITE, Color::BLACK]);
+
+		let single = stops_of(vec![Color::WHITE]);
+		assert_eq!(single.iter().map(|stop| (stop.position, stop.color)).collect::<Vec<_>>(), vec![(0., Color::WHITE), (1., Color::WHITE)]);
+
+		let empty = stops_of(Vec::new());
+		assert_eq!(empty.iter().map(|stop| (stop.position, stop.color)).collect::<Vec<_>>(), vec![(0., Color::BLACK), (1., Color::BLACK)]);
+	}
+
+	#[test]
+	fn a_group_converts_to_its_legacy_list() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let layout = graphic_layout();
+		let rows = vec![(text("a"), translation(1.)), (text("b"), translation(2.))];
+		let node = install(
+			WrapNode::new(RecordSource::new(GraphicSource { layout: layout.clone(), rows }, &layout, &layout), &layout),
+			wrap_layout_meta(),
+			&[Some(&layout)],
+		);
+		let out = Node::<ContextImpl>::layout(&node).clone();
+		let head = ctx.index_head();
+		let GPoll::Final(value) = record::serve_input(&node, &ctx.promoted(&head, 0), &frames) else {
+			panic!("expected a final record");
+		};
+		let Graphic::Group(group) = (unsafe { record::borrow_element::<Graphic>(out.rec(&value)) }) else {
+			panic!("expected a group element");
+		};
+
+		let legacy = graphic_types::graphic::group_to_legacy_list(group);
+		assert_eq!(legacy.len(), 2);
+		for (index, (label, x)) in [("a", 1.), ("b", 2.)].into_iter().enumerate() {
+			assert_eq!(text_of(legacy.element(index).unwrap()), label, "item {index}");
+			assert_eq!(legacy.attribute_cloned_or_default::<DAffine2>(ATTR_TRANSFORM, index).translation.x, x, "item {index}");
+		}
+	}
+
+	#[test]
+	fn flatten_reverses_wrap() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let layout = graphic_layout();
+		let rows = vec![(text("a"), translation(1.)), (text("b"), translation(2.))];
+		let wrapped = install(
+			WrapNode::new(RecordSource::new(GraphicSource { layout: layout.clone(), rows }, &layout, &layout), &layout),
+			wrap_layout_meta(),
+			&[Some(&layout)],
+		);
+		let wrap_out = Node::<ContextImpl>::layout(&wrapped).clone();
+		let head = ctx.index_head();
+		let group = {
+			// SAFETY: the element is cloned out inside the scope, so no borrow
+			// into the frame escapes it. The clone is shallow, so the `'static`
+			// the `GraphicSource` rows infer launders a borrow of `arena`: it is
+			// contained because `arena` outlives every use below and this test
+			// never resets it, so the interior stays resident for the whole
+			// generation the group is read in.
+			let scope = frames.scope();
+			let GPoll::Final(value) = record::serve_input(&wrapped, &ctx.promoted(&head, 0), &scope) else {
+				panic!("expected a final record");
+			};
+			unsafe { record::borrow_element::<Graphic>(wrap_out.rec(&value)) }.clone()
+		};
+
+		// One row holding the wrapped group flattens back to the lanes, the
+		// group's identity transform composed onto each child's.
+		let node = build!(layout, vec![(group, DAffine2::IDENTITY)], false);
+		assert_eq!(node.extent_at(&ctx, 0, &frames.reborrow()), GPoll::Final(Extent::Exactly(2)));
+
+		let head = ctx.index_head();
+		for (lane, &(label, x)) in [("a", 1.), ("b", 2.)].iter().enumerate() {
+			let GPoll::Final(record) = record::capture(&node, &ctx.promoted(&head, lane as u64), &frames) else {
+				panic!("expected a final record");
+			};
+			assert_eq!(text_of(&record.element::<Graphic>()), label, "lane {lane}");
+			let transform: DAffine2 = record.attr::<Transform>();
+			assert_eq!(transform.translation.x, x, "lane {lane}");
+		}
+	}
+
+	#[test]
+	fn flatten_fully_composes_the_path() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let mut rows = fixture_rows();
+		rows.push((group(vec![]), translation(9.)));
+		let layout = graphic_layout();
+		let node = build!(layout, rows, true);
+		assert_eq!(node.extent_at(&ctx, 0, &frames.reborrow()), GPoll::Final(Extent::Exactly(3)), "the empty group contributes no leaves");
+
+		let head = ctx.index_head();
+		let expected: [(&str, f64); 3] = [("a", 1.), ("b", 20.5), ("c", 4300.5)];
+		for (lane, &(label, x)) in expected.iter().enumerate() {
+			let GPoll::Final(record) = record::capture(&node, &ctx.promoted(&head, lane as u64), &frames) else {
+				panic!("expected a final record");
+			};
+			assert_eq!(text_of(&record.element::<Graphic>()), label, "lane {lane}");
+			let transform: DAffine2 = record.attr::<Transform>();
+			assert_eq!(transform.translation.x, x, "lane {lane}");
+		}
+	}
+
+	#[test]
+	fn flatten_batch_matches_per_lane_eval() {
+		let frames = core_types::record::test_frames(1 << 16);
+		let arena = Arena::new(1 << 16).unwrap();
+		let generations = [];
+		let scope = scope_fixture(&generations, &arena);
+		let ctx = ContextImpl::root(&scope);
+
+		let layout = graphic_layout();
+		let node = build!(layout, fixture_rows(), true);
+		let out = Node::<ContextImpl>::layout(&node).clone();
+		let head = ctx.index_head();
+		let scoped = ctx.promoted(&head, 0);
+
+		let mut scratch = vec![std::mem::MaybeUninit::<u64>::uninit(); 3 * out.lane_stride() / 8];
+		let core_types::node::BatchStatus::Filled(batch, ..) = node.eval_batch(&scoped, 0..3, Some(&mut scratch), &frames) else {
+			panic!("expected a filled batch");
+		};
+		let batch = batch.into_shared();
+		assert_eq!(batch.len(), 3);
+		let offset = out.offset_of(<Transform as AttributeMarker>::NAME, 0).unwrap();
+		for lane in 0..3 {
+			let GPoll::Final(record) = record::capture(&node, &ctx.promoted(&head, lane as u64), &frames) else {
+				panic!("expected a final record");
+			};
+			let single = text_of(&record.element::<Graphic>()).to_string();
+			assert_eq!(text_of(unsafe { record::borrow_element::<Graphic>(batch.get(lane).rec()) }), single, "lane {lane}");
+			let batched: DAffine2 = unsafe { batch.get(lane).rec().read(offset) };
+			let direct: DAffine2 = record.attr::<Transform>();
+			assert_eq!(batched, direct, "lane {lane}");
+		}
+	}
+}