diff --git a/README.md b/README.md
index 11006da9f..9caf7cee1 100644
--- a/README.md
+++ b/README.md
@@ -271,7 +271,7 @@ Guidance on selecting a client, the coverage of the four newer clients, and the
 ## Goals
 
 - **Performance:** sub-millisecond parsing, a single static binary, and no JVM or Eclipse runtime
-- **Completeness:** SysML v2 textual notation support (104 of 104 standard library files parse cleanly: 94 vendored OMG files and 10 OpenSysML extensions)
+- **Completeness:** SysML v2 textual notation support (105 of 105 standard library files parse cleanly: 94 vendored OMG files and 11 OpenSysML extensions)
 - **Executable models:** instantiate, evaluate and simulate, turning specifications into running systems
 - **Practical ergonomics:** multi-file workspaces, incremental analysis and detailed diagnostics
 
@@ -281,7 +281,7 @@ The project is under active development, with the core infrastructure operationa
 
 | Component | Status |
 |-----------|--------|
-| Lexer/Parser (structural + behavioral grammar) | ✅ Operational (104/104 stdlib clean - see [conformance gate](internal/workspace/libs/stdlib_conformance_test.go)) |
+| Lexer/Parser (structural + behavioral grammar) | ✅ Operational (105/105 stdlib clean - see [conformance gate](internal/workspace/libs/stdlib_conformance_test.go)) |
 | Symbol resolution & type system | ✅ Complete |
 | Semantic layer (operators, builtins, validation) | ✅ Complete |
 | Feature chain resolution (member access) | ✅ Complete |
@@ -327,7 +327,7 @@ What these numbers cannot show: the OMG corpora are demonstrations rather than a
 
 **Current commit:** All tests pass (`go test -race ./...`), builds clean (`go build ./...`).
 **Test coverage:** top-level `Test` functions (counted from the `_test.go` files, as `go test ./...` runs them) covering parsers, semantics, runtime (actions, states, instances, operators, validation), behind golden ASTs, negatives, execution conformance cases, golden traces, runtime robustness cases and gRPC conformance and robustness cases. The figures are counted from the tree when the documentation site is built into the test inventory of [spec compliance](docs/project/spec-compliance.md), never committed, so a branch adding a test does not rewrite this page. A test skips only for want of something the run did not provide, and says what: the held-image round trip declines a conformance case that creates no instance, a few gate on a PDF or Mermaid toolchain, a pinned pilot artifact, the PSSM suite, a locale, a case-insensitive filesystem or a live Flexo stack, and the OMG corpus gates skip until the corpora are downloaded unless asked to fail.
-**Parser coverage:** 104/104 bundled library files parse cleanly — the 94 official SysML v2 standard library files and the non-normative `OpenSysML Libraries/OpenSysMLMathFunctions.kerml`, `OpenSysML Libraries/DocumentQueries.sysml`, `OpenSysML Libraries/IdentityMetadata.sysml`, `OpenSysML Libraries/DiagramLayout.sysml`, `OpenSysML Libraries/OOSEM.sysml`, `OpenSysML Libraries/MOSA.sysml`, `OpenSysML Libraries/StateSpaceIntegration.sysml`, `OpenSysML Libraries/Stochastic.sysml`, `OpenSysML Libraries/RandomFunctions.kerml` and `OpenSysML Libraries/Simulation.sysml` extensions. Conformance verified by [stdlib_conformance_test.go](internal/workspace/libs/stdlib_conformance_test.go). Grammar reference: [OMG Xtext grammar](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation/tree/master/org.omg.kerml.xtext/src/org/omg/kerml/xtext).
+**Parser coverage:** 105/105 bundled library files parse cleanly — the 94 official SysML v2 standard library files and the non-normative `OpenSysML Libraries/OpenSysMLMathFunctions.kerml`, `OpenSysML Libraries/DocumentQueries.sysml`, `OpenSysML Libraries/IdentityMetadata.sysml`, `OpenSysML Libraries/DiagramLayout.sysml`, `OpenSysML Libraries/OOSEM.sysml`, `OpenSysML Libraries/MOSA.sysml`, `OpenSysML Libraries/StateSpaceIntegration.sysml`, `OpenSysML Libraries/Stochastic.sysml`, `OpenSysML Libraries/RandomFunctions.kerml`, `OpenSysML Libraries/Simulation.sysml` and `OpenSysML Libraries/MigrationMetadata.sysml` extensions. Conformance verified by [stdlib_conformance_test.go](internal/workspace/libs/stdlib_conformance_test.go). Grammar reference: [OMG Xtext grammar](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation/tree/master/org.omg.kerml.xtext/src/org/omg/kerml/xtext).
 **Behavioral execution:** Calc/constraint/requirement/satisfy functional. Action/state executors handle nested invocation, control flow keywords, loop and conditional statements and the send statement (<!-- doc-counts:begin conformance-passing -->every conformance case passing<!-- doc-counts:end conformance-passing -->). Coverage is self-assessed against the specification text and the normative library: the pinned OMG pilot implementation evaluates expressions but does not execute actions or state machines headlessly, so no external implementation currently adjudicates these rows. See [spec compliance](docs/project/spec-compliance.md).
 **Reference differential:** 378 files compared diagnostic-by-diagnostic against the pinned OMG pilot implementation (`2026-08`), 347 in full agreement; every divergence is enumerated and adjudicated in [the differential](docs/project/pilot-differential.md), reproducible with `go run -C tools ./cmd/pilot-diff`.
 **Rejection oracle:** the reverse direction — do we reject what the reference rejects? 306 hand-written invalid models validated by both implementations, 297 rejected by both, 0 the pinned pilot rejects and we accept; the remainder only we reject — the control-node succession rules the pinned pilot leaves unimplemented and a non-Boolean succession guard it accepts once the standard library types it — and every permissiveness gap is enumerated with a reproducer and likely root cause in [the rejection oracle](docs/project/pilot-rejection.md), reproducible with `go run -C tools ./cmd/pilot-reject`. We wrote every case, so the count measures our coverage of the rejection surface, not our conformance — a sample, not a proof.
@@ -391,7 +391,7 @@ github.com/Open-MBEE/OpenSysML
 - **Parser:** hand-written recursive descent (no framework overhead, full error recovery, sub-millisecond parses)
 - **Grammar source:** OMG pilot Xtext grammars (`SysML.xtext` and `KerMLExpressions`)
 - **Spec compliance:** [OMG SysML v2.1 Beta 1 / KerML 1.1](https://www.omg.org/spec/SysML/2.0) (2026-08 release)
-- **Standard library:** 94 files from [SysML v2 Pilot Implementation 2026-08](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation/releases/tag/2026-08), byte-identical, plus the ten non-normative `OpenSysML Libraries/` extensions (`OpenSysMLMathFunctions`, `DocumentQueries`, `IdentityMetadata`, `DiagramLayout`, [`OOSEM`](docs/project/oosem-library.md), [`MOSA`](docs/project/mosa-library.md), `StateSpaceIntegration`, `Stochastic`, `RandomFunctions` and `Simulation`)
+- **Standard library:** 94 files from [SysML v2 Pilot Implementation 2026-08](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation/releases/tag/2026-08), byte-identical, plus the eleven non-normative `OpenSysML Libraries/` extensions (`OpenSysMLMathFunctions`, `DocumentQueries`, `IdentityMetadata`, `DiagramLayout`, [`OOSEM`](docs/project/oosem-library.md), [`MOSA`](docs/project/mosa-library.md), `StateSpaceIntegration`, `Stochastic`, `RandomFunctions`, `Simulation` and `MigrationMetadata`)
 - **CI/CD:** GitHub Actions checks pull requests; CircleCI builds and tests `main` and `develop` and publishes releases from tags
 
 ## Releases
diff --git a/changes/unreleased/positioned-label-fitting.fixed.md b/changes/unreleased/positioned-label-fitting.fixed.md
new file mode 100644
index 000000000..537b8ba82
--- /dev/null
+++ b/changes/unreleased/positioned-label-fitting.fixed.md
@@ -0,0 +1,7 @@
+- **A positioned node's label fits the box its `DiagramLayout::Layout` states; the box is never grown to the label.** The DOT writer word-wraps the head at the stated width and draws it at the largest font size from 14 pt down to 8 pt at which the wrapped lines fit the height, keeps the `«keyword»` and detail lines only while height remains, and cuts and ellipsizes a head that overruns even at 8 pt, using the same glyph estimate the unsized boxes are fitted with; the box's `margin=0` gives the whole of it to the label, as the fit assumes. A migrated Cameo diagram, whose boxes were sized for the name alone, reads as it did: a 449×14 px attribute row holds its one line, `call : doTracking` no longer spills out of its action box, and Graphviz's `size too small for label` warnings on such a model drop to none. A stated box that holds other stated boxes — a part drawn round its members, a definition over its compartment rows — sets its title in the strip above the topmost of them, fitted to that strip, so the title is read as the frame's header rather than covered by the members, which stay where the Layout put them; a box drawn as a cluster round its children is fitted the same way. A stated box, or the strip its members leave it, too short for one 8 pt line or too narrow for one glyph holds no text, and sets its head beside the box instead. A node without a stated size keeps its label-fitted box.
+- **A control node or port in a stated box is drawn as its notation symbol, with no text inside.** A decision, merge or choice is a diamond, a fork or join the filled bar, an initial node the filled dot, a final node or terminate action the double ring, and a port its small square; the node's name is set beside the symbol as an `xlabel`, and left out when the view IR marks it as one the model did not give (`Node.NameSynthesized`). Without a stated box these kinds keep their labelled shapes, except that an action's `start` and `done` — the language's names, not the body's — are now the filled dot and the double ring in every graphical form, where they were a large labelled circle.
+- **A name the SysML v1 migration made up is not drawn.** The migrator now records every name it spells for an element its source left unnamed — `'start to call'`, `fork2`, `decide`, an `unnamed` ref — once per body, as `metadata MigrationMetadata::SynthesizedName about …;` from the new bundled `MigrationMetadata` library. The renderings read the marker from the model: such a node is drawn as its source drew it — a control node as its bare symbol, a typed usage as `: Type` alone — and an edge whose only text would be such a name carries none, while a triggered transition or a guarded succession keeps its trigger and guard. Names the source gave, however spelled, are never marked; the migration report and results are unchanged.
+- **A member drawn under its owner is headed by its name below that owner.** A nested node, or an exposed element whose owner is drawn in the same rendering, no longer repeats the owner's qualified path: `'K-Mirror Offset'::'interpolation Error' : 'Interpolation Error'` inside the `'K-Mirror Offset'` box reads `'interpolation Error' : 'Interpolation Error'`, as a diagram frame shows it. Only the graphical forms' heads change; the text and JSON forms and the LSP keep the qualified name.
+- **A positioned DOT drawing leaves the nodes no `Layout` places undrawn, so none lands on a placed box.** When some nodes of a view are positioned and others are not, the DOT writer left the others to `neato`, which set them wherever it found room — over the positioned boxes, in a migrated diagram whose source never drew them. They are now left out, with the edges at them, under a `// not represented:` notice that counts them, so the drawing shows what the source diagram showed; every node drawn is pinned, so the `// layout:` header names `neato -n` or `neato -n2` and never plain `neato`. The new `-render-unplaced strip` (`Options.Unplaced` in the view API) keeps them instead, boxed and packed in rows below the canvas or the positioned boxes' extent, clear of them and of one another; it applies to `-render`, `-render-all` and the `dot` diagrams of `-render-document` and `-render-documents`, and an unknown placement is refused with the two there are. A view with no positioned node is laid out by `dot` as before.
+- **A view's layout annotations and `render` members are not drawn as nodes.** The member walk every rendering kind shares leaves out `DiagramLayout::Canvas`, `Layout` and `Route` annotations, wherever they are owned, the `MigrationMetadata::SynthesizedName` markers a migration leaves in a body, and the `render` members a view holds, so a tree over a package of migrated views no longer fills with `metadata`, `x`, `y`, `width`, `height` and `asTreeDiagram` nodes. Every other metadata usage, and a rendering usage outside a view, is drawn as before.
+- **A parallel state may carry a metadata usage in its body.** Lowering a `state … parallel` body treated a `metadata` member as unsupported content and refused the whole state machine, so its state rendering came out empty; the annotation is now the state's own, like an attribute or a port, and its substates alone are the regions.
diff --git a/cmd/sysml/main.go b/cmd/sysml/main.go
index c62067464..b75601323 100644
--- a/cmd/sysml/main.go
+++ b/cmd/sysml/main.go
@@ -129,6 +129,7 @@ var (
 	renderAllDir     string
 	renderForm       string
 	renderPalette    string
+	renderUnplaced   string
 	renderDoc        string
 	renderDocsDir    string
 	docForm          string
@@ -386,6 +387,10 @@ func runCLI() int {
 		fmt.Fprintln(os.Stderr, "sysml: -render-palette is the palette -render or -render-all fills DOT or PlantUML with; name the view to render with -render or a directory with -render-all")
 		return 2
 	}
+	if renderUnplaced != "" && renderView == "" && renderAllDir == "" && renderDoc == "" && renderDocsDir == "" {
+		fmt.Fprintln(os.Stderr, "sysml: -render-unplaced places the unplaced nodes of a positioned DOT drawing; name what to render with -render, -render-all, -render-document or -render-documents")
+		return 2
+	}
 
 	// The default stylesheet is asked for on its own; it needs no model, and
 	// writing it is the whole run, so it cannot stand in for another.
@@ -510,7 +515,7 @@ func runCLI() int {
 		case convertFormat != "" || renderView != "" || renderDoc != "" || renderAllDir != "" || renderDocsDir != "" || queryText != "" || len(evalExprs) > 0:
 			fmt.Fprintf(os.Stderr, "sysml: %s syncs a change set; it cannot be combined with -convert, -render, -render-all, -render-document, -render-documents, -query or -eval\n", mode)
 			return 2
-		case outputPath != "" || fromFormat != "" || renderForm != "" || renderPalette != "" || docForm != "" || diagramForm != "" || pdfEngine != "" || pdfTitlePage || pdfTOC || pdfNumbering:
+		case outputPath != "" || fromFormat != "" || renderForm != "" || renderPalette != "" || renderUnplaced != "" || docForm != "" || diagramForm != "" || pdfEngine != "" || pdfTitlePage || pdfTOC || pdfNumbering:
 			fmt.Fprintf(os.Stderr, "sysml: %s reads SysML or Turtle inputs and reports the change set; -output, -from and the render options do not apply\n", mode)
 			return 2
 		case modelChecks.requested():
diff --git a/cmd/sysml/render.go b/cmd/sysml/render.go
index 5a225edf5..add4c18a6 100644
--- a/cmd/sysml/render.go
+++ b/cmd/sysml/render.go
@@ -189,7 +189,8 @@ func caseFolded(text string) string {
 }
 
 // renderOptions is what -render and -render-all write with: the text width,
-// and the palette -render-palette names, which must be one there is.
+// the palette -render-palette names and the placement -render-unplaced names,
+// each of which must be one there is.
 func renderOptions(width int) (view.Options, error) {
 	options := view.Options{Width: width}
 	if renderPalette != "" {
@@ -199,9 +200,28 @@ func renderOptions(width int) (view.Options, error) {
 		}
 		options.Palette = palette
 	}
+	unplaced, err := unplacedOption()
+	if err != nil {
+		return view.Options{}, err
+	}
+	options.Unplaced = unplaced
 	return options, nil
 }
 
+// unplacedOption is the placement -render-unplaced names for the nodes a
+// positioned DOT drawing leaves unplaced, which must be one there is; none
+// named is the default, leaving them undrawn.
+func unplacedOption() (view.Unplaced, error) {
+	if renderUnplaced == "" {
+		return "", nil
+	}
+	unplaced, ok := view.ParseUnplaced(renderUnplaced)
+	if !ok {
+		return "", fmt.Errorf("-render-unplaced: %w", &view.UnknownUnplacedError{Name: renderUnplaced})
+	}
+	return unplaced, nil
+}
+
 // loadRenderingModel loads and reports a model whose stdout is reserved for
 // rendering artifacts.
 func loadRenderingModel(files []string) (*repl.Session, error) {
diff --git a/cmd/sysml/render_document.go b/cmd/sysml/render_document.go
index 4864140d4..6e01856c1 100644
--- a/cmd/sysml/render_document.go
+++ b/cmd/sysml/render_document.go
@@ -82,6 +82,7 @@ func pdfOptions() (docpdf.Options, error) {
 		Stylesheets:         page.Stylesheets,
 		BaseDir:             filepath.Dir(outputPath),
 		DiagramForm:         page.DiagramForm,
+		Unplaced:            page.Unplaced,
 	}, nil
 }
 
@@ -147,16 +148,21 @@ func documentOptions() docrender.HTMLOptions {
 		MermaidScript:       mermaidScriptURL(),
 		MathScript:          mathScriptURL(),
 		DiagramForm:         view.Form(diagramForm),
+		Unplaced:            view.Unplaced(renderUnplaced),
 	}
 }
 
 // markdownOptions carries the flags shaping a Markdown document.
 func markdownOptions() docrender.MarkdownOptions {
-	return docrender.MarkdownOptions{DiagramForm: view.Form(diagramForm)}
+	return docrender.MarkdownOptions{DiagramForm: view.Form(diagramForm), Unplaced: view.Unplaced(renderUnplaced)}
 }
 
-// checkDiagramForm rejects a -diagram-form value naming no diagram form.
+// checkDiagramForm rejects a -diagram-form value naming no diagram form, and
+// a -render-unplaced value naming no placement.
 func checkDiagramForm() error {
+	if _, err := unplacedOption(); err != nil {
+		return err
+	}
 	if diagramForm == "" || slices.Contains(view.DiagramForms(), view.Form(diagramForm)) {
 		return nil
 	}
diff --git a/cmd/sysml/render_unplaced_test.go b/cmd/sysml/render_unplaced_test.go
new file mode 100644
index 000000000..5798d60fd
--- /dev/null
+++ b/cmd/sysml/render_unplaced_test.go
@@ -0,0 +1,101 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// TestRenderUnplaced checks -render-unplaced on every path that draws a DOT
+// figure: a positioned drawing leaves the nodes no Layout places undrawn by
+// default and sets them in a strip below it under `strip`, the same on
+// -render, -render-all, -render-document and -render-documents; an unknown
+// placement and a placement with nothing to render are refused.
+func TestRenderUnplaced(t *testing.T) {
+	binary := buildCLI(t)
+	fixture := filepath.Join("..", "..", "internal", "doc", "docrender", "testdata", "placed_report.sysml")
+	const (
+		omitted = "// not represented: 1 node(s) without a position, left undrawn\n"
+		striped = "// not represented: 1 node(s) without a position, drawn in a strip below the drawing\n"
+		spare   = "<b>spare : Recorder</b>"
+	)
+	check := func(t *testing.T, path, got string, strip bool) {
+		t.Helper()
+		notice := omitted
+		if strip {
+			notice = striped
+		}
+		if !strings.Contains(got, notice) {
+			t.Errorf("%s: notice %q missing:\n%s", path, notice, got)
+		}
+		if strings.Contains(got, spare) != strip {
+			t.Errorf("%s: spare drawn = %v, want %v:\n%s", path, !strip, strip, got)
+		}
+		if strings.Contains(got, "neato -n\n") && strings.Contains(got, `pos="82,-42.5!"`) != strip {
+			t.Errorf("%s: the strip pins spare below the canvas only when asked:\n%s", path, got)
+		}
+	}
+	readFile := func(t *testing.T, path string) string {
+		t.Helper()
+		content, err := os.ReadFile(path) // #nosec G304 -- the test chose this path.
+		if err != nil {
+			t.Fatal(err)
+		}
+		return string(content)
+	}
+
+	for _, strip := range []bool{false, true} {
+		var placement []string
+		if strip {
+			placement = []string{"-render-unplaced", "strip"}
+		}
+		one := runFiles(t, binary, []string{fixture}, append([]string{"-render", "Placed::placedView", "-render-form", "dot"}, placement...)...)
+		if one.status != exitHolds {
+			t.Fatalf("-render exit status = %d, want %d\n%s", one.status, exitHolds, one.output())
+		}
+		check(t, "-render", one.stdout, strip)
+
+		dir := filepath.Join(t.TempDir(), "rendered")
+		all := runFiles(t, binary, []string{fixture}, append([]string{"-render-all", dir, "-render-form", "dot"}, placement...)...)
+		if all.status != exitHolds {
+			t.Fatalf("-render-all exit status = %d, want %d\n%s", all.status, exitHolds, all.output())
+		}
+		check(t, "-render-all", readFile(t, filepath.Join(dir, "Placed.placedView.dot")), strip)
+
+		doc := runFiles(t, binary, []string{fixture}, append([]string{"-render-document", "Placed::PlacedReport", "-diagram-form", "dot"}, placement...)...)
+		if doc.status != exitHolds {
+			t.Fatalf("-render-document exit status = %d, want %d\n%s", doc.status, exitHolds, doc.output())
+		}
+		check(t, "-render-document", doc.stdout, strip)
+
+		site := filepath.Join(t.TempDir(), "docs")
+		docs := runFiles(t, binary, []string{fixture}, append([]string{"-render-documents", site, "-diagram-form", "dot"}, placement...)...)
+		if docs.status != exitHolds {
+			t.Fatalf("-render-documents exit status = %d, want %d\n%s", docs.status, exitHolds, docs.output())
+		}
+		pages, err := filepath.Glob(filepath.Join(site, "*.md"))
+		if err != nil || len(pages) != 1 {
+			t.Fatalf("-render-documents wrote %v, want one page: %v", pages, err)
+		}
+		check(t, "-render-documents", readFile(t, pages[0]), strip)
+	}
+
+	mermaid := runFiles(t, binary, []string{fixture}, "-render", "Placed::placedView", "-render-form", "mermaid", "-render-unplaced", "strip")
+	if mermaid.status != exitHolds || strings.Contains(mermaid.stdout, "pos=") {
+		t.Errorf("Mermaid under -render-unplaced = %d\n%s", mermaid.status, mermaid.output())
+	}
+
+	unknown := runFiles(t, binary, []string{fixture}, "-render", "Placed::placedView", "-render-form", "dot", "-render-unplaced", "below")
+	if unknown.status != exitUnevaluable || !strings.Contains(unknown.stderr, `-render-unplaced: unknown placement "below" of unplaced nodes; the placements are omit, strip`) {
+		t.Errorf("an unknown placement = %d\n%s", unknown.status, unknown.output())
+	}
+	if unknown.stdout != "" {
+		t.Errorf("an unknown placement wrote an artifact:\n%s", unknown.stdout)
+	}
+
+	alone := runFiles(t, binary, []string{fixture}, "-render-unplaced", "strip")
+	if alone.status != 2 || !strings.Contains(alone.stderr, "-render-unplaced places the unplaced nodes of a positioned DOT drawing") {
+		t.Errorf("a placement without a view = %d\n%s", alone.status, alone.output())
+	}
+}
diff --git a/cmd/sysml/usage.go b/cmd/sysml/usage.go
index 2bbf857e7..505c8bf24 100644
--- a/cmd/sysml/usage.go
+++ b/cmd/sysml/usage.go
@@ -360,6 +360,7 @@ func doc() usage.Doc {
 				usage.Ex("sysml model.sysml -render Views::vehicleView -o view.mmd", ""),
 				usage.Ex("sysml model.sysml -render Views::vehicleView -render-form dot", ""),
 				usage.Ex("sysml model.sysml -render Views::vehicleView -render-form dot -render-palette okabe-ito", ""),
+				usage.Ex("sysml model.sysml -render Views::vehicleView -render-form dot -render-unplaced strip", "unpositioned nodes in a strip below"),
 				usage.Ex("sysml model.sysml -render Views::vehicleView -render-form plantuml -o view.puml", ""),
 				usage.Ex("sysml types.sysml model.sysml -render Views::vehicleView", "several files, loaded as one model"),
 				usage.Ex("sysml model.sysml -render-all rendered", ""),
@@ -384,7 +385,13 @@ func doc() usage.Doc {
 					"black-and-white style of the SysML v2 Pilot visualizer; -render-palette " +
 					"fills their nodes by keyword family from a colourblind-safe palette " +
 					"(okabe-ito, tol-bright, tol-muted, tol-light, brewer-set2, brewer-dark2, " +
-					"viridis or cividis), keeping black text legible on every fill.",
+					"viridis or cividis), keeping black text legible on every fill. " +
+					"A DOT drawing of a view whose members carry DiagramLayout positions " +
+					"pins each at its stated place and leaves a member with no position " +
+					"undrawn, so nothing lands on a positioned box; -render-unplaced strip " +
+					"draws those members instead, in rows in a strip below the drawing. " +
+					"The same setting shapes the DOT diagrams of -render-document and " +
+					"-render-documents.",
 			},
 		}, {
 			Title: "Rendering a document",
@@ -586,6 +593,7 @@ func registerFlags(fs *flag.FlagSet) {
 	fs.StringVar(&renderAllDir, "render-all", "", "Render every declared view into this directory")
 	fs.StringVar(&renderForm, "render-form", "", "Form -render or -render-all writes: text, mermaid, markdown, dot or plantuml; default from the destination for -render, each kind's machine form for -render-all")
 	fs.StringVar(&renderPalette, "render-palette", "", "Palette the dot or plantuml form fills nodes from, by keyword family: okabe-ito, tol-bright, tol-muted, tol-light, brewer-set2, brewer-dark2, viridis or cividis; default black and white")
+	fs.StringVar(&renderUnplaced, "render-unplaced", "", "Where the dot form of a view some Layout positions puts the nodes none does: omit (default) leaves them undrawn, strip draws them in rows below the drawing; applies to -render, -render-all and document diagrams")
 
 	fs.StringVar(&renderDoc, "render-document", "", "Compile this document definition, run its queries and write the rendered document")
 	fs.StringVar(&renderDocsDir, "render-documents", "", "Render every document definition, linked to one another, into this directory")
@@ -719,6 +727,7 @@ func optionGroups() []usage.OptionGroup {
 			usage.Opt("render-all", "<dir>"),
 			usage.Opt("render-form", formArg),
 			usage.Opt("render-palette", "<palette>"),
+			usage.Opt("render-unplaced", "<placement>"),
 		},
 	}, {
 		Title: "Rendering documents",
diff --git a/docs/internals/architecture.md b/docs/internals/architecture.md
index 137507962..6b78b70c1 100644
--- a/docs/internals/architecture.md
+++ b/docs/internals/architecture.md
@@ -662,7 +662,7 @@ See [the guide](../guide/) for VS Code configuration.
 | Standard library bundling | ✅ Complete |
 | LSP server implementation | ✅ Complete |
 
-**Parser coverage:** 105/105 bundled library files parse cleanly — the 94 official SysML v2 standard library files and the 11 non-normative OpenSysML extensions: `OpenSysML Libraries/OpenSysMLMathFunctions.kerml`, `DocumentQueries.sysml`, `IdentityMetadata.sysml`, `OOSEM.sysml`, `DiagramLayout.sysml`, `MOSA.sysml`, `RandomFunctions.kerml`, `Simulation.sysml`, `StateSpaceIntegration.sysml`, `Stochastic.sysml` and `AnalysisRecords.sysml`. Conformance verified by [stdlib_conformance_test.go](../../internal/workspace/libs/stdlib_conformance_test.go). Grammar reference available at [OMG Xtext grammar](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation/tree/master/org.omg.kerml.xtext/src/org/omg/kerml/xtext).
+**Parser coverage:** 106/106 bundled library files parse cleanly — the 94 official SysML v2 standard library files and the 12 non-normative OpenSysML extensions: `OpenSysML Libraries/OpenSysMLMathFunctions.kerml`, `DocumentQueries.sysml`, `IdentityMetadata.sysml`, `OOSEM.sysml`, `DiagramLayout.sysml`, `MOSA.sysml`, `RandomFunctions.kerml`, `Simulation.sysml`, `StateSpaceIntegration.sysml`, `Stochastic.sysml`, `AnalysisRecords.sysml` and `MigrationMetadata.sysml`. Conformance verified by [stdlib_conformance_test.go](../../internal/workspace/libs/stdlib_conformance_test.go). Grammar reference available at [OMG Xtext grammar](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation/tree/master/org.omg.kerml.xtext/src/org/omg/kerml/xtext).
 
 ---
 
@@ -675,8 +675,8 @@ New grammar features require a **four-layer test contract** to ensure correctnes
 #### 1. Conformance Gate
 - **Purpose:** Ensure stdlib continues to parse cleanly
 - **Location:** `internal/workspace/libs/stdlib_conformance_test.go`
-- **Test:** `TestStdlibConformance` loads all 105 bundled library files
-- **Acceptance:** 105/105 files parse without errors
+- **Test:** `TestStdlibConformance` loads all 106 bundled library files
+- **Acceptance:** 106/106 files parse without errors
 - **Allowlist:** `testdata/stdlib_known_failures.txt` (currently empty)
 - **Failure mode:** Regression breaks previously-working stdlib files
 
diff --git a/docs/internals/testing.md b/docs/internals/testing.md
index d43b22338..d94e88fa4 100644
--- a/docs/internals/testing.md
+++ b/docs/internals/testing.md
@@ -34,7 +34,7 @@ New grammar features require a **four-layer test contract**:
 **Purpose:** Ensure standard library continues to parse cleanly
 
 - **Test:** `TestStdlibConformance` (internal/workspace/libs/)
-- **Coverage:** 104/104 bundled library files — the 94 official SysML v2 standard library files and ten non-normative OpenSysML extensions
+- **Coverage:** 106/106 bundled library files — the 94 official SysML v2 standard library files and twelve non-normative OpenSysML extensions
 - **Acceptance:** All stdlib files parse without errors
 - **Allowlist:** `testdata/stdlib_known_failures.txt` (currently empty)
 
diff --git a/docs/project/pilot-differential-baseline.json b/docs/project/pilot-differential-baseline.json
index 9a0b2695b..7b76b7f2a 100644
--- a/docs/project/pilot-differential-baseline.json
+++ b/docs/project/pilot-differential-baseline.json
@@ -61,7 +61,7 @@
         "dir": "examples",
         "origin": "ours",
         "files": 43,
-        "digest": "sha256:18b2fbd67ec48deea2777902bd8a7f6bbb238f44107f28c52a7cda2ef0ff9e83"
+        "digest": "sha256:3e4522077d7c4903aa3c6cad01dc84abc79588f9f13c62e7c5aee8c9bee1a02f"
       },
       {
         "name": "probes",
diff --git a/docs/project/spec-compliance.md b/docs/project/spec-compliance.md
index 000268b21..d9e12653f 100644
--- a/docs/project/spec-compliance.md
+++ b/docs/project/spec-compliance.md
@@ -2010,8 +2010,8 @@ semantics layer over the conjugation parity of the typing/specialization chain.
 | A view's exposed elements are queryable (SysML v2 7.24 Views and Viewpoints, 8.3.26 Expose) | `semantics/expose.go` `Model.ExposedElements` (a view's own `expose` relationships, then those of the views it specializes since an Expose is protected, in declaration order and once each) and `Model.NestedViews` (the views in its body, to walk a view tree), enumerated by `resolve/filter.go` `Resolver.ImportedElements` — the same admission, visibility and filter gating a lookup through that import makes, so the exposed set is what the view body actually resolves | `semantics/expose_test.go` (`TestExposedElementsNamespaceWildcard`, `TestExposedElementsRecursiveExpose`, `TestExposedElementsWithAnElementFilter`, `TestExposedElementsWithAViewBodyFilter`, `TestExposedElementsOfNestedViews`, `TestExposedElementsExposingAnotherView`, `TestExposedElementsInheritedFromAViewDefinition`, `TestExposedElementsOfAViewExposingNothing`, `TestExposedElementsOfANonView`) | ✅ Faithful (an empty exposed set is no error; asking a non-view is `semantics.ErrNotAView`. The REPL surface is `%view` — `repl/view.go` `doView`) |
 | A view's exposed set is rendered as the rendering its `render` member states, and as a containment tree where it states none (SysML v2 7.24 Views and Viewpoints, §10.2 — the rendering is tool-defined) | `semantics/rendering.go` `Model.ViewRenderings` (the `render` members of the view and of the views it specializes) and `Model.RenderingTarget` (the rendering the member references or declares); `view/view.go` `Renderer.KindOf`, `Renderer.Render` (the kind, then the exposed set from `Model.ExposedElements`) and `Renderer.RenderExposed` (an arbitrary selected set); `view/pseudo.go` derives the `#<kind>` vocabulary from the kinds this build supports; `view/tree.go`, `view/interconnection.go` (the model's own connector and flow ends, not source text), `view/behavior.go` (the lowered `lower.StateGraph`/`lower.ActionGraph`, never a re-parse of `symbol.Decl`), `view/table.go` (the exposed elements, the elements declared in them and the nested views, as rows), `view/sequence.go` `Renderer.renderSequence` (the occurrences an interaction declares as lifelines, the model's own flow ends as directed messages, ordered by the successions between the events those messages run between), `view/text.go`, `view/mermaid.go` and `view/markdown.go` (the forms, chosen per kind by `Kind.MachineForm` in `view/form.go`) | `view/render_test.go` `TestGoldenRenderings` (text and machine-readable goldens for tree, interconnection, state, action, a filtered view and a table, from `.sysml` fixtures), `TestTreeRenderingShowsNestedViewsAndDefaults`, `TestInterconnectionRenderingDrawsConnections`, `TestStateRenderingComesFromTheLoweredGraph`, `TestActionRenderingComesFromTheLoweredGraph`, `TestRenderingUsesFilteredAndInheritedExposure`, `TestTableRenderingRows`, `TestTableFormsAreMarkdownNotMermaid`, `TestMermaidLabelsAreEscaped`; `view/sequence_test.go` `TestSequenceRenderingDrawsLifelinesAndMessages`, `TestSequenceRenderingFromTheShortViewName`, `TestSequenceRenderingReportsWhatItCannotShow`, `TestSequenceRenderingHonoursStatedOrder`, `TestSequenceRenderingReportsASuccessionCycle`, `TestSequenceMermaidDeclaresParticipantsFirst`; `view/pseudo_test.go` | ✅ Faithful to the notation, tool-defined in output (the kinds produced are a tree, an interconnection diagram, a state machine, an action flow, a sequence diagram and a table; state and action renderings read the graphs the runtime executes, so a rendering cannot drift from what runs. Mermaid is the machine-readable form of the graph-shaped kinds and Markdown that of a table; SysML §10.2 specifies no artifact) |
 | A rendering this build does not produce, a name that is no view, a view exposing nothing, and an exposed element a rendering cannot represent are each explicit | `view/view.go` `UnsupportedKindError` (wrapping `view.ErrUnsupportedKind`, naming the kind, the view and the rendering it stated), `Renderer.Render` (`semantics.ErrNotAView` for a non-view, as `%view` answers), `Rendering.Empty` and `view/text.go` (an empty artifact saying whether the view exposes nothing or nothing exposed was representable), `Rendering.Notices` (what a kind could not draw); `cmd/sysml/render.go` reports and skips unsupported declared views and incompatible forced forms during `-render-all`, prefixing each notice with its source view | `view/render_test.go` `TestUnsupportedRenderingKinds`, `TestRenderingSomethingThatIsNoView`, `TestRenderingAViewExposingNothing`, `TestRenderingReportsWhatItCannotRepresent`; `repl/view_render_test.go` `TestRenderOfAnUnsupportedKindNamesIt`, `TestRenderOfANonViewIsTyped`, `TestRenderOfAViewExposingNothingSaysSo`; `cmd/sysml/render_test.go` `TestRenderReportsWhatItCouldNotDo`, `TestRenderAllSkipsUnsupportedKindsAndWrongForcedForms`, `TestRenderAllPrefixesRenderingNoticesWithTheirView` | ✅ Faithful (a stated kind that is not produced is a typed error naming it, never a substituted rendering; a form the kind is not written in is a `WrongFormError` naming the one it is; an element that cannot be drawn is reported, not dropped. A one-view render stops on either typed error; a render-all run skips only that view and renders the rest) |
-| A graph-shaped rendering (tree, interconnection, state, action) is also written as Graphviz DOT, an alternative to Mermaid for Graphviz toolchains and large-graph layouts, without a Graphviz installation: a `digraph` with `// view:`, `// kind:`, `// stated:`, `// not represented:`, `// canvas:` and `// layout:` header comments, `rankdir` from the direction, containment as `subgraph "cluster_<id>"` (a tree as `arrowhead=none` edges, as its Mermaid form), an edge at a cluster drawn to a node inside it and clipped with `lhead`/`ltail`, state pseudo-states as `point`/`circle`/`doublecircle`, states as rounded boxes, regions as dashed clusters, transition labels as the state writer's trigger/guard/effect text, and edge kinds parallel to the Mermaid arrows (connection `arrowhead=none`, flow `style=dashed`, transition and succession solid); every identifier and label is quoted through one helper; the DiagramLayout geometry is written as Graphviz reads it, one pixel to one point with y flipped from the library's y-down origin (`inputscale=72`, `dpi=72`; y measured from the canvas's bottom edge, negated with no canvas height): a positioned node pinned at the centre of its box with `pos="x,y!", pin=true`, its size as `width`/`height` in inches — a stated size with `fixedsize=true`, an unstated one fitted to the label so the box's corner stays where the Layout put it — `collapsed` as `comment="collapsed"`, a positioned cluster's `bb` stated (its stated box, or the one from its corner round its positioned members) and its anchor pinned at the centre, a `Route` as the edge's `pos` B-spline through its waypoints (a route of one waypoint drawn as no line and noticed as `// not represented:`), a sized `Canvas` as an invisible point pinned at each corner so the drawing's bounding box is the canvas, and the `// layout:` header naming `neato -n2` when every node is placed and any edge routed, `neato -n` when every node is placed and none routed, `neato` when some nodes are, `dot` when none; sequence and table have no DOT form and are the same `WrongFormError` the other forms raise | `view/dot.go` `Rendering.DOT`, `Rendering.DOTWith`, `dotWriter` (`engine`, `graphAttributes`, `dotNodeAttributes`, `dotPin`, `dotBox`, `dotClusterAttributes`, `dotAnchorAttributes`, `clusterBox`, `dotEdgeAttributes`, `dotSpline`, `flipY`, `dotInches`), `dotQuote`; `view/form.go` `FormDot`, `Forms`, `DiagramForms`, `Kind.SupportsForm`, `Options`, `Write`, `WriteWith`; `cmd/sysml/render.go` (`-render-form dot`, `.dot` under `-render-all`); `repl/meta.go` (`%render <name> dot`); `lsp/render.go` `renderForm` (`form: "dot"`) | `view/dot_test.go` `TestGoldenDOT` (`testdata/*.dot.golden` beside the Mermaid goldens, each checked by an in-test DOT syntax walker: balanced braces, every edge endpoint declared as a node or cluster, quoted identifiers), `TestDOTFormSupport`, `TestDOTQuotesEveryIdentifierAndLabel`, `TestDOTNestedClusters`, `TestDOTDirections`, `TestDOTEdgeKinds`, `TestDOTStateShapesAndLabels`, `TestDOTEmptyAndNotices`, `TestDOTWritesTheGeometry` (`testdata/layout.dot.golden` beside the Mermaid and text goldens of the layout fixture; the flipped axis with and without a canvas height; states and transitions placed), `TestDOTPinsEveryNode` (`neato -n` and `neato -n2`, the one-waypoint notice, a stated, a member-fitted and a corner-only cluster's `bb` and anchor, a tree's positioned parent, pseudo-state centring, the zero-extent, unit-only and unpositioned canvas); the syntax walker parses every `pos` and `bb`; `cmd/sysml/render_test.go` `TestRenderDotForm`; `repl/view_render_test.go` `TestRenderWritesDotWhenAskedFor`; `lsp/render_test.go` `TestRenderWritesDotWhenAskedFor` | ✅ Faithful to the notation, tool-defined in output (Mermaid stays the machine-readable form `Kind.MachineForm` chooses; DOT is written on request. Producing the DOT needs no `dot` binary, and the goldens are validated by the in-test syntax walker rather than by `dot -Tsvg`; the one place Graphviz runs is the PDF backend, drawing the block on request when a Graphviz is installed (the document-rendering rows below). A `Route` is written as the polyline through its waypoints, not smoothed; a node with no stated size is given the writer's estimate of its label's extent (8.4 pt a glyph, 16.8 pt a line), not `fixedsize`, so Graphviz may grow the box for its own font and move the corner by the difference. The gRPC API has no view-render RPC — `RenderDocument` alone, to Markdown — so no wire contract carries a form) |
-| The DOT form draws in the Standard B&W style of the OMG SysML v2 Pilot Implementation's PlantUML visualizer (SysML v2 §8.2.2.2, the graphical notation's rendering being tool-defined), after the `sysmlbw` PlantUML skin by Hisashi Miyashita (Mgnite Inc.) shipped with the Pilot and the edge rules of its `SysML2PlantUMLStyle.java`, reproducing the skin's visual parameters rather than its text: Helvetica text at 14 pt on nodes and 13 pt on edges, white fills, `#181818` lines at `penwidth=0.5` on nodes and `1` on edges, a definition (`… def`, or a KerML classifier keyword) square and a usage `style="rounded,filled"`, the name in bold over the `«keyword»` line in italics at its 10 pt size, clusters unfilled with black borders — `penwidth=1.5` for a package, `0.5` for an element's cluster and a region (which keeps `style=dashed`) — a connection at `penwidth=3` with `arrowhead=none`, flow, succession and transition as before, and an unnamed initial or final pseudo-state as the filled black UML dot (`shape=circle`/`doublecircle`, `fillcolor=black`, `label=""`, `width=0.2` unless a Layout sizes it) while a named one keeps its labelled ring; every style attribute precedes the geometry in a node's list, and geometry, node IDs, label text, escaping, routes, cluster anchors, `lhead`/`ltail`, the header comments and the order of nodes and edges are the ones the DOT form always wrote | `view/dot.go` `dotNodeDefaults`, `dotEdgeDefaults`, `dotControlKinds`, `dotNodeAttributes`, `dotPseudostateAttributes`, `dotClusterAttributes`, `dotClusterPenwidth`, `dotEdgeAttributes`, `dotLabel`; `view/palette.go` `isDefinitionKind`, `kermlClassifierKinds` | `view/dot_style_test.go` `TestDOTStandardDefaults`, `TestDOTDefinitionsSquareUsagesRounded`, `TestDOTPseudostateRules`, `TestDOTClusterBorders`, `TestDOTConnectionPenwidth`, `TestDOTEscapesNamesInStyledLabels`; every `view/testdata/*.dot.golden`, reviewed so that only style attributes and the italic keyword markup moved; `docrender/testdata/*.golden.*`, `repl/view_render_test.go`, `cmd/sysml/render_test.go`, `lsp/render_test.go` | ⚠️ Approximate (the skin's 20-unit `UsageRoundCorner` is Graphviz's fixed `rounded` radius; its `Shadowing 0`, `hide circle` and `wrapWidth 300` have no Graphviz counterpart and nothing to turn off; the skin's plain-weight state title is not followed — a state's name stays bold like every other kind's, so the text, Mermaid and DOT forms read alike; the Pilot's `-[thickness=5]-` binding connectors are not drawn apart from connections because the interconnection rendering has no edge kind for them; the skin's notes, sequence, gantt, mindmap and wbs sections are out of the DOT form's scope. Producing DOT still runs no Graphviz binary; the goldens are checked by the in-test syntax walker, and a Graphviz installation is used only by hand to look at them) |
+| A graph-shaped rendering (tree, interconnection, state, action) is also written as Graphviz DOT, an alternative to Mermaid for Graphviz toolchains and large-graph layouts, without a Graphviz installation: a `digraph` with `// view:`, `// kind:`, `// stated:`, `// not represented:`, `// canvas:` and `// layout:` header comments, `rankdir` from the direction, containment as `subgraph "cluster_<id>"` (a tree as `arrowhead=none` edges, as its Mermaid form), an edge at a cluster drawn to a node inside it and clipped with `lhead`/`ltail`, state pseudo-states as `point`/`circle`/`doublecircle`, states as rounded boxes, regions as dashed clusters, transition labels as the state writer's trigger/guard/effect text, and edge kinds parallel to the Mermaid arrows (connection `arrowhead=none`, flow `style=dashed`, transition and succession solid); every identifier and label is quoted through one helper; the DiagramLayout geometry is written as Graphviz reads it, one pixel to one point with y flipped from the library's y-down origin (`inputscale=72`, `dpi=72`; y measured from the canvas's bottom edge, negated with no canvas height): a positioned node pinned at the centre of its box with `pos="x,y!", pin=true`, its size as `width`/`height` in inches — a stated size with `fixedsize=true` and the label fitted to it (the head wrapped at the width and shrunk from 14 pt to 8 pt until it fits, the keyword and detail lines kept only while height remains, an overrunning head ellipsized), an unstated one fitted to the label so the box's corner stays where the Layout put it — `collapsed` as `comment="collapsed"`, a positioned cluster's `bb` stated (its stated box, or the one from its corner round its positioned members) and its anchor pinned at the centre, a `Route` as the edge's `pos` B-spline through its waypoints (a route of one waypoint drawn as no line and noticed as `// not represented:`), a sized `Canvas` as an invisible point pinned at each corner so the drawing's bounding box is the canvas, and the `// layout:` header naming `neato -n2` when every node is placed and any edge routed, `neato -n` when every node is placed and none routed, `neato` when some nodes are, `dot` when none; sequence and table have no DOT form and are the same `WrongFormError` the other forms raise | `view/dot.go` `Rendering.DOT`, `Rendering.DOTWith`, `dotWriter` (`engine`, `graphAttributes`, `dotNodeAttributes`, `dotPin`, `dotBox`, `dotClusterAttributes`, `dotAnchorAttributes`, `clusterBox`, `dotEdgeAttributes`, `dotSpline`, `flipY`, `dotInches`), `dotQuote`; `view/form.go` `FormDot`, `Forms`, `DiagramForms`, `Kind.SupportsForm`, `Options`, `Write`, `WriteWith`; `cmd/sysml/render.go` (`-render-form dot`, `.dot` under `-render-all`); `repl/meta.go` (`%render <name> dot`); `lsp/render.go` `renderForm` (`form: "dot"`) | `view/dot_test.go` `TestGoldenDOT` (`testdata/*.dot.golden` beside the Mermaid goldens, each checked by an in-test DOT syntax walker: balanced braces, every edge endpoint declared as a node or cluster, quoted identifiers), `TestDOTFormSupport`, `TestDOTQuotesEveryIdentifierAndLabel`, `TestDOTNestedClusters`, `TestDOTDirections`, `TestDOTEdgeKinds`, `TestDOTStateShapesAndLabels`, `TestDOTEmptyAndNotices`, `TestDOTWritesTheGeometry` (`testdata/layout.dot.golden` beside the Mermaid and text goldens of the layout fixture; the flipped axis with and without a canvas height; states and transitions placed), `TestDOTPinsEveryNode` (`neato -n` and `neato -n2`, the one-waypoint notice, a stated, a member-fitted and a corner-only cluster's `bb` and anchor, a tree's positioned parent, pseudo-state centring, the zero-extent, unit-only and unpositioned canvas); the syntax walker parses every `pos` and `bb`; `cmd/sysml/render_test.go` `TestRenderDotForm`; `repl/view_render_test.go` `TestRenderWritesDotWhenAskedFor`; `lsp/render_test.go` `TestRenderWritesDotWhenAskedFor` | ✅ Faithful to the notation, tool-defined in output (Mermaid stays the machine-readable form `Kind.MachineForm` chooses; DOT is written on request. Producing the DOT needs no `dot` binary, and the goldens are validated by the in-test syntax walker rather than by `dot -Tsvg`; the one place Graphviz runs is the PDF backend, drawing the block on request when a Graphviz is installed (the document-rendering rows below). A `Route` is written as the polyline through its waypoints, not smoothed; a node with no stated size is given the writer's estimate of its label's extent (8.4 pt a glyph, 16.8 pt a line), not `fixedsize`, so Graphviz may grow the box for its own font and move the corner by the difference. The gRPC API has no view-render RPC — `RenderDocument` alone, to Markdown — so no wire contract carries a form) |
+| The DOT form draws in the Standard B&W style of the OMG SysML v2 Pilot Implementation's PlantUML visualizer (SysML v2 §8.2.2.2, the graphical notation's rendering being tool-defined), after the `sysmlbw` PlantUML skin by Hisashi Miyashita (Mgnite Inc.) shipped with the Pilot and the edge rules of its `SysML2PlantUMLStyle.java`, reproducing the skin's visual parameters rather than its text: Helvetica text at 14 pt on nodes and 13 pt on edges, white fills, `#181818` lines at `penwidth=0.5` on nodes and `1` on edges, a definition (`… def`, or a KerML classifier keyword) square and a usage `style="rounded,filled"`, the name in bold over the `«keyword»` line in italics at its 10 pt size, clusters unfilled with black borders — `penwidth=1.5` for a package, `0.5` for an element's cluster and a region (which keeps `style=dashed`) — a connection at `penwidth=3` with `arrowhead=none`, flow, succession and transition as before, and an unnamed initial or final pseudo-state as the filled black UML dot (`shape=circle`/`doublecircle`, `fillcolor=black`, `label=""`, `width=0.2` unless a Layout sizes it) while a named one keeps its labelled ring unless a Layout sizes it; a decision, merge, choice, fork, join, initial, final or port a Layout sizes drawn as its symbol with no inner text, its name as an `xlabel` unless the view IR marks it synthesized; every style attribute precedes the geometry in a node's list, and geometry, node IDs, label text, escaping, routes, cluster anchors, `lhead`/`ltail`, the header comments and the order of nodes and edges are the ones the DOT form always wrote | `view/dot.go` `dotNodeDefaults`, `dotEdgeDefaults`, `dotControlKinds`, `dotNodeAttributes`, `dotPseudostateAttributes`, `dotClusterAttributes`, `dotClusterPenwidth`, `dotEdgeAttributes`, `dotLabel`; `view/palette.go` `isDefinitionKind`, `kermlClassifierKinds` | `view/dot_style_test.go` `TestDOTStandardDefaults`, `TestDOTDefinitionsSquareUsagesRounded`, `TestDOTPseudostateRules`, `TestDOTClusterBorders`, `TestDOTConnectionPenwidth`, `TestDOTEscapesNamesInStyledLabels`; every `view/testdata/*.dot.golden`, reviewed so that only style attributes and the italic keyword markup moved; `docrender/testdata/*.golden.*`, `repl/view_render_test.go`, `cmd/sysml/render_test.go`, `lsp/render_test.go` | ⚠️ Approximate (the skin's 20-unit `UsageRoundCorner` is Graphviz's fixed `rounded` radius; its `Shadowing 0`, `hide circle` and `wrapWidth 300` have no Graphviz counterpart and nothing to turn off; the skin's plain-weight state title is not followed — a state's name stays bold like every other kind's, so the text, Mermaid and DOT forms read alike; the Pilot's `-[thickness=5]-` binding connectors are not drawn apart from connections because the interconnection rendering has no edge kind for them; the skin's notes, sequence, gantt, mindmap and wbs sections are out of the DOT form's scope. Producing DOT still runs no Graphviz binary; the goldens are checked by the in-test syntax walker, and a Graphviz installation is used only by hand to look at them) |
 | A graph-shaped rendering (tree, interconnection, state, action) and a sequence are also written as PlantUML, the language the OMG Pilot's own visualizer draws with, without Java or a PlantUML jar: an `@startuml` … `@enduml` file with the `' <view> — <kind> rendering (<stated>)` header comment and one `' not represented:` line per notice and per loss the writer itself incurs, the Standard B&W style inline as a `<style>` block plus `skinparam wrapWidth 300` and `hide stereotype`, `top to bottom direction`/`left to right direction` from the direction (a reversed `BT`/`RL` takes the nearest forward one under a notice, since PlantUML draws no reversed direction; a sequence ignores it), and the DiagramLayout geometry as `' canvas:`, `' layout:` and `' route:` comments in the Mermaid form's shape under a notice naming the `dot` form for pinned positions; a tree as a class diagram (`hide circle`, `hide empty members`, containment as `parent -- child` edges as the Mermaid and DOT trees draw it), an interconnection as nested `rectangle` blocks with a port a nested rectangle, a state or action rendering as the `state` grammar (composite states as nested blocks, a body's start as `[*] -->` inside it as the Mermaid writer's `starts` map places it, control nodes as PlantUML's `<<start>>`, `<<end>>`, `<<fork>>`, `<<join>>`, `<<choice>>`, `<<history>>`, `<<history*>>` pseudostates — a merge and a junction as `<<choice>>`, PlantUML having no round junction; an action takes the state grammar uniformly, PlantUML's activity syntax being procedural), a sequence as `participant`s in root order and `->` messages in edge order (an empty rendering as one participant, rectangle or state carrying `EmptyReason()`); edges as the Pilot draws them — a connection `-[thickness=3]-`, a flow `-[dashed]->`, a transition and a succession `-->`, labelled as the DOT form labels them; every node's keyword a stereotype (`<<part def>>`, `<<state>>`) with a `<<usage>>`/`<<package>>` shape stereotype beside it for the style to select on, and the rendering's identifier-safe node IDs as the aliases; a `table`, `textual` or `geometry` rendering is refused with `WrongFormError` | `view/plantuml.go` `Rendering.PlantUML`, `Rendering.PlantUMLWith`, `plantumlWriter` (`writeStyle`, `writeClassDiagram`, `writeRectangleDiagram`, `writeStateDiagram`, `writeSequenceDiagram`, `writeEdge`, `writeArrow`, `decoration`), `plantumlDirection`, `plantumlArrow`, `plantumlPseudostates`, `plantumlShapeStereotype`, `plantumlLabel`, `plantumlQuote`, `plantumlText`, `Rendering.countGeometry`; `view/mermaid.go` `writeGeometryComments`, `writeLayoutComments` (the comment prefix a parameter, shared with the Mermaid form); `view/form.go` `FormPlantUML`, `Forms`, `DiagramForms`, `Kind.SupportsForm`, `WriteWith`; `cmd/sysml/render.go` (`-render-form plantuml`, `.puml` under `-render-all`); `repl/meta.go` (`%render <name> plantuml`); `lsp/render.go` `renderForm` (`form: "plantuml"`) | `view/plantuml_test.go` `TestGoldenPlantUML` (`testdata/*.plantuml.golden` beside every Mermaid golden, the `sequence-*` and `layout` fixtures included, each checked by `checkPlantUMLSyntax`, an in-test walker: `@startuml`/`@enduml` bracketing, balanced braces, a closed `<style>` block, every quoted label closed, every alias an arrow names declared), `TestPlantUMLDrawsEveryNodeAndEdge` (every node and edge of every golden model, against the rendering), `TestPlantUMLTreeIsAClassDiagram`, `TestPlantUMLInterconnectionNestsRectangles`, `TestPlantUMLStateDiagram`, `TestPlantUMLActionUsesStateGrammar`, `TestPlantUMLSequenceDiagram`, `TestPlantUMLFormSupport` (the five kinds written, the three refused), `TestPlantUMLDirection`, `TestPlantUMLEscapesLabels`, `TestPlantUMLLabelShape`, `TestPlantUMLHeaderAndGeometryComments` (the Mermaid geometry comments unchanged byte for byte); `checkPlantUMLRenders` runs `java -jar … -checkonly` over each golden only when `OPENSYSML_PLANTUML_JAR` names a jar, and is skipped otherwise; `cmd/sysml/render_test.go` `TestRenderPlantUMLForm`; `repl/view_render_test.go` `TestRenderWritesPlantUMLWhenAskedFor`; `lsp/render_test.go` `TestRenderWritesPlantUMLWhenAskedFor` | ✅ Faithful to the notation, tool-defined in output (Mermaid stays the machine-readable form `Kind.MachineForm` chooses; PlantUML is written on request. Producing the PlantUML needs no Java, and the goldens are validated by the in-test syntax walker, the jar check being opt-in by hand; the one place the jar runs is the PDF backend, drawing the block on request when a jar and a Java are installed (the document-rendering rows below). Not honoured: a DiagramLayout position or route, which PlantUML cannot pin — kept as comments and noticed, the `dot` form being the one that draws them; a reversed direction. Not written: hyperlinks, since no writer derives a stable URL from `Origin`; a port on the boundary — `portin`/`portout` is a component-diagram construct and a port is a nested rectangle instead; an action as PlantUML activity syntax, whose procedural `start`/`:action;`/`fork`/`if` shape cannot hold an arbitrary graph of successions and flows losslessly, so every action rendering takes the state grammar. The gRPC API has no view-render RPC, so no wire contract carries the form) |
 | The PlantUML form draws in the Standard B&W style of the OMG SysML v2 Pilot Implementation's PlantUML visualizer (SysML v2 §8.2.2.2, the graphical notation's rendering being tool-defined), after the `sysmlbw` PlantUML skin by Hisashi Miyashita (Mgnite Inc.) shipped with the Pilot and the edge rules of its `SysML2PlantUMLStyle.java`, translated into rules the file carries itself since PlantUML proper does not ship the skin: a `<style>` block with `root` (white background, `SansSerif` 14 pt black text, `#181818` lines, left alignment), `element` (white fill, `LineThickness 0.5`, `RoundCorner 0`, `Shadowing 0.0`), `arrow` (`#181818` at thickness 1, 13 pt text), `note` (`#FEFFDD`, 13 pt), `.usage { RoundCorner 20 }`, `.package { LineThickness 1.5 }` and `.region { LineStyle 4 }`, then `skinparam wrapWidth 300` and `hide stereotype`; a definition (`… def`, or a KerML classifier keyword) square and a usage rounded by its `<<usage>>` stereotype, the name in bold creole over the `«keyword»` line italic at 10 pt inside the label (the stereotypes hidden, so one guillemet line is printed, not two), pseudostates and containers black and white under every palette, a connection at `thickness=3` undirected | `view/plantuml.go` `writeStyle`, the `plantuml*` style constants, `plantumlUsageStereotype`, `plantumlPackageStereotype`, `plantumlShapeStereotype`, `plantumlLabel`, `plantumlKeywordFontSize`, `plantumlArrow`, `decoration`; `view/palette.go` `isDefinitionKind`, `kermlClassifierKinds` | `view/plantuml_test.go` `TestGoldenPlantUML`, `TestPlantUMLLabelShape`, `TestPlantUMLTreeIsAClassDiagram`, `TestPlantUMLInterconnectionNestsRectangles`, `TestPlantUMLStateDiagram`, `TestPlantUMLEscapesLabels`; every `view/testdata/*.plantuml.golden`, reviewed by eye | ⚠️ Approximate (the skin's three rules the DOT form could not honour — the 20-unit usage corner radius, shadows off and the 300-pixel wrap — are honoured here; the skin's plain-weight state title is not followed, a state's name staying bold like every other kind's so the text, Mermaid, DOT and PlantUML forms read alike; the Pilot's `-[thickness=5]-` binding connectors are not drawn apart from connections because the interconnection rendering has no edge kind for them; the skin's `monochrome` mode, notes, gantt, mindmap and wbs sections are out of the form's scope; the guillemet line is the label's, not PlantUML's stereotype rendering, so its size is the label's `<size:10>` rather than the skin's `stereotype` rule. Producing PlantUML runs no jar; the goldens are checked by the in-test syntax walker, and a jar is used only by hand to look at them) |
 | A `view.Palette` names a colourblind-safe palette the DOT and PlantUML forms fill nodes with by keyword family, the same hex per node in both, the way the Pilot visualizer's `STDCOLOR` mode colours by element kind: `okabe-ito` (Okabe & Ito 2002), `tol-bright`, `tol-muted`, `tol-light` (Paul Tol, SRON note 3.2), `brewer-set2`, `brewer-dark2` (ColorBrewer, Apache-2.0 notice kept), `viridis` and `cividis` (matplotlib's ramps at 16 stops). The families are ordered part, item, port, attribute, action, state, requirement, constraint, connection, interface, use case, case, allocation, analysis, verification, enum, occurrence, flow, other; a kind is placed by the first of its words with a family, `def` set aside, so a definition and its usages share a hue; a qualitative palette is indexed by the family's fixed rank (wrapping past its last colour), a sequential one sampled evenly across the families present, darkest first. A definition is filled with the family colour, a usage with it blended 60 % toward white, both bordered in the colour at `penwidth=1`; every fill is lightened toward white until black text on it reaches the WCAG 2 AA ratio of 4.5:1; pseudo-states, control nodes and cluster borders stay black and white. The palette travels with the direction in one `view.Options`: `Diagram::palette` in `DocumentQueries.sysml`, `-render-palette`, `%render <name> dot <palette>` (completed), the `palette` field of `opensysml/render`, the document plan and IR, and `data-palette` on the HTML figure. Mermaid notes a palette as `%% not represented:`; text and Markdown ignore it; a name that is no palette is one typed `*view.UnknownPaletteError` naming the palettes there are, and a document block's is `invalid-palette` or, on a kind with no DOT form, `unsupported-palette` | `view/palette.go` `Palette`, `Palettes`, `ParsePalette`, `PaletteNames`, `UnknownPaletteError`, `ErrUnknownPalette`, `Palette.check` (a `Palette` value outside the registry is the same error at `DOTWith`), `paletteColors`, `Palette.Color`, `Palette.Sequential`, `paletteFamilies`, `paletteFamily`, `familyRank`, `paletteFill`, `legibleFill`, `contrastWithBlack`, `Kind.SupportsPalette`, `Form.TakesPalette`, `paletteForms`, `familyFills`, `paletteNotice`; `view/form.go` `Options`, `WriteWith`; `view/dot.go` `dotNodeAttributes`; `view/plantuml.go` `plantumlWriter.decoration` (`#hex;line:hex` on the element, a sequence participant's fill without the border); `view/mermaid.go` `MermaidWith`; `libs/stdlib/OpenSysML Libraries/DocumentQueries.sysml` `Diagram::palette`; `docplan/compiler.go` `compileDiagram`, `docplan/errors.go` `ErrorInvalidPalette`, `ErrorUnsupportedPalette`; `docir/ir.go` `Content.Palette`, `Content.Options`; `docrender/markdown.go`, `docrender/html.go`; `cmd/sysml/render.go` `renderOptions`; `repl/view.go`, `repl/complete.go` `atPaletteArgument`, `renderPalettes`; `lsp/render.go` `renderPalette` | `view/palette_test.go` `TestPaletteRegistry`, `TestUnknownPaletteError`, `TestPaletteColorsAsPublished`, `TestPaletteColorForCategory`, `TestPaletteFamilyIndex`, `TestPaletteFillsAreLegible`, `TestPaletteNotice`, `view/dot_style_test.go` `TestDOTPaletteFills`, `TestDOTRefusesAnUnregisteredPalette`, `TestDOTSequentialPaletteSpansFamiliesPresent`, `TestPaletteOnOtherForms`, `TestGoldenDOTPalettes` (`testdata/interconnection.okabe-ito.dot.golden`, `state.okabe-ito.dot.golden`, `tree.viridis.dot.golden`); `view/plantuml_test.go` `TestPlantUMLPaletteParityWithDOT` (the same fill per node as DOT over every golden model and every palette), `TestGoldenPlantUMLPalettes` (`testdata/interconnection.okabe-ito.plantuml.golden`), `TestPlantUMLSequencePaletteFillsParticipants`, `TestPlantUMLRefusesAnUnregisteredPalette`; `docplan/diagram_test.go` (accepted, invalid and unsupported palettes), `docir/diagram_test.go`, `docrender/html_diagram_test.go`; `cmd/sysml/render_test.go`, `repl/view_render_test.go`, `lsp/render_test.go` (accepted and refused palettes, the Mermaid notice) | ✅ Faithful to the notation, tool-defined in output (a kind supports a palette when a form that fills nodes writes it — DOT or PlantUML — so a sequence takes one for its PlantUML participants while a table takes none; colouring is by keyword family only; colouring by a data attribute or query result, and Mermaid theming, are not built, though `Palette.Color(i, n)` is shaped for a later caller to colour categories without knowing families) |
diff --git a/docs/project/view-rendering-forms.md b/docs/project/view-rendering-forms.md
index 15371a340..392840eb5 100644
--- a/docs/project/view-rendering-forms.md
+++ b/docs/project/view-rendering-forms.md
@@ -22,6 +22,19 @@ action kinds are produced from the model — the last two from the lowered `Stat
 `ActionGraph` the runtime executes — and nothing in the rendering is text of any diagram
 language.
 
+What a kind walks into nodes is model content. A view's own bookkeeping is left out of every
+kind, by the one member walk the kinds share (`contentKind` in `tree.go`): a
+[DiagramLayout](diagram-layout-annotations.md) annotation — a `Canvas`, `Layout` or `Route`,
+whether a prefix `@Layout` or a `metadata Layout about …` member, wherever it is owned — and the
+`render` members a view holds (`render asTreeDiagram;`, `render rendering r : AsTree;`). Both say
+how a picture is drawn, not what the model is, so a tree over a package of migrated views draws
+those views without the `metadata` and `render` nodes their annotations would add. The
+`MigrationMetadata::SynthesizedName` marker a migration leaves in a body is left out the same way:
+it records what the migration did, not what the model holds. Every other metadata usage — a
+user's `metadata Approved about errorCBE { by = "review"; }`, an annotation typed by any
+definition outside `DiagramLayout` and `MigrationMetadata` — is drawn as before, and a rendering
+usage owned by anything but a view (a `rendering` under a package) stays a node.
+
 A **form** is a writer over that tree (`internal/ir/view/form.go`):
 
 | Form | Writer | Kinds | Role |
@@ -46,7 +59,11 @@ the element's name first, the kind after it. `label.go` composes the lines once,
 only joins them:
 
 1. the name, with ` : Type` after it for a typed usage (`pump : Pump`); a definition has just its
-   name; an anonymous element leads with its kind instead;
+   name; an anonymous element leads with its kind instead, or with ` : Type` alone when typed.
+   A name the model did not give is not shown and the node heads as an anonymous one: a name a
+   [v1 migration](../reference/sysml-v1-migration.md) made up for an element its source left
+   unnamed, which it marks with `MigrationMetadata::SynthesizedName`, and the language's own
+   `start` and `done` of an action's flow (`Node.NameSynthesized`, `shown` in `label.go`);
 2. the kind in guillemets, `«part»`, `«state def»` — left out when line 1 is already the kind;
 3. the detail, when there is one.
 
@@ -59,8 +76,15 @@ every named root shares — the longest run of leading qualifier names common to
 `Radio` beside `Braking::Brake`, and roots from unrelated packages keep their whole names — and
 a type is named by the name each of its references ends in, its `~` kept (`~Ports::FuelPort` is
 `~FuelPort`; `Pump, ~FuelPort` for a pair); a name the roots' namespace does not head, and a type
-that does not read as references, are shown whole. The DOT writer sizes a box from the same
-label it emits, so a Cameo-sized box holds what it is headed with.
+that does not read as references, are shown whole. A member drawn under a drawn owner — a child
+node, or a nested exposed element whose owner is a node of the same rendering — is headed by its
+name below the nearest such owner, as a compartment or a nested box in a diagram frame shows it:
+`'K-Mirror Offset'::'interpolation Error' : 'Interpolation Error'` under the `'K-Mirror Offset'`
+node heads `'interpolation Error' : 'Interpolation Error'`, and a name with a single segment is
+shown whole. Only the graphical heads change: `Node.Name`, the JSON and the text form keep the
+qualified name. The DOT writer sizes a box from the same label it emits, so a box a Layout does
+not size holds what it is headed with; a box a Layout sizes has its label fitted to it
+([Geometry](#geometry)).
 
 Mermaid joins the lines with `<br>` in every grammar it writes — a flowchart node label, a
 `state "…" as n` and a `participant n as …` — which the pinned `mermaid-cli` breaks at whether
@@ -92,8 +116,10 @@ binding — is labelled by its name, `'off then on'`. The rule holds for every k
 whether the model's author gave it or the [v1 migration](../reference/sysml-v1-migration.md#edges-a-diagram-shows)
 spelled it from the ends: a triggered transition named `idle_to_moving` reads `accept Signal
 [temperature > 0]`, as the graphical notation draws it, since the name adds nothing a reader
-looks for and a migrated name would only repeat the ends. The rule is one place, so the text,
-Mermaid, DOT and PlantUML forms label an edge alike.
+looks for and a migrated name would only repeat the ends. A name the migration made up because
+the source had none (`MigrationMetadata::SynthesizedName`) never becomes a label: an edge with no
+text of its own and such a name is drawn unlabelled, as its source drew it. The rule is one place,
+so the text, Mermaid, DOT and PlantUML forms label an edge alike.
 
 ## Why DOT next to Mermaid
 
@@ -207,11 +233,12 @@ translation to DOT is:
 | `arrow { FontSize 13; LineThickness 1.0 }` | edge default `color="#181818", fontsize=13, penwidth=1` |
 | Pilot `caseConnectionUsage`, `caseConnector`: `-[thickness=3]-` | `EdgeConnection`: `arrowhead=none, penwidth=3` |
 | Pilot `caseFlow`, `caseSuccession`, `caseTransitionUsage`: `-->` | the `EdgeKind` table above, unchanged |
-| initial and final pseudo-states | the UML filled black dot: `shape=circle` (`doublecircle` for a final), `fillcolor=black`, `label=""`, `width=0.2` unless a Layout sizes it; a pseudo-state the rendering names keeps its labelled ring. The `start` point is unchanged |
+| initial and final pseudo-states | the UML filled black dot: `shape=circle` (`doublecircle` for a final), `fillcolor=black`, `label=""`, `width=0.2` unless a Layout sizes it; a pseudo-state the model names keeps its labelled ring unless a Layout sizes it. An action's `start` and `done`, being the language's names and not the body's, and a name a migration made up (`Node.NameSynthesized`) are the dot and the ring, as the notation draws them. The `start` point is unchanged |
+| symbol kinds in a stated box | a node whose Layout states a size and whose kind has a notation symbol is drawn as the symbol with no text inside it: `decision`, `merge` and `choice` as `shape=diamond`; `fork` and `join` as the filled bar (the stated box, `fillcolor=black`); `initial` and `junction` as the filled dot; `final` and a terminate action as `shape=doublecircle, fillcolor=black`; a port (`port`, `ref port`, not a `port def`) as its stated square, filled by the palette when one is set. The head the node would have carried is set beside the symbol as `xlabel="…"`, a plain string, and left out when `Node.NameSynthesized` marks the name as one a migration made up |
 
 Not translated, because Graphviz has no vocabulary for them: `Shadowing 0` (no shadows to turn
-off), `hide circle` (no class circles), `wrapWidth 300` (DOT does not wrap label text), and the
-20-unit corner radius. Out of scope: the skin's notes, sequence, gantt, mindmap and wbs
+off), `hide circle` (no class circles), `wrapWidth 300` (DOT does not wrap label text; the writer
+wraps only a head it fits to a stated box), and the 20-unit corner radius. Out of scope: the skin's notes, sequence, gantt, mindmap and wbs
 sections — the DOT form draws no notes and a sequence rendering has no DOT form. The Pilot's
 `-[thickness=5]-` binding connectors are `EdgeBinding`, drawn as a plain undirected line: thinner
 than a connection, not heavier, so a binding reads as the equation it is rather than a channel.
@@ -277,7 +304,7 @@ preprocessing step:
 // kind: interconnection
 // stated: render asInterconnectionDiagram
 // canvas: unit=px w=1200 h=800
-// layout: neato
+// layout: neato -n2
 digraph "PlantViews::placedView" {
   graph [fontname="Helvetica", inputscale=72, dpi=72];
   node [shape=box, style=filled, fillcolor=white, color="#181818", fontname="Helvetica", fontsize=14, penwidth=0.5];
@@ -288,9 +315,10 @@ digraph "PlantViews::placedView" {
     label=<<b>Loop</b><br/><font point-size="10"><i>«part def»</i></font>>;
     color=black;
     penwidth=0.5;
-    "n0" [shape=point, style=invis, width=0, height=0, label=""];
+    bb="292,692,628,768";
+    "n0" [shape=point, style=invis, width=0, height=0, label="", pos="460,730!", pin=true];
     "n1" [style="rounded,filled", label=<<b>pump : Pump</b><br/><font point-size="10"><i>«part»</i></font>>, pos="359,741.5!", pin=true, width=1.6388888888888888, height=0.5138888888888888, comment="collapsed"];
-    "n2" [style="rounded,filled", label=<<b>tank : Tank</b><br/><font point-size="10"><i>«part»</i></font>>, pos="560,730!", pin=true, width=1.6666666666666667, height=0.8333333333333334, fixedsize=true];
+    "n2" [style="rounded,filled", label=<<b>tank : Tank</b><br/><font point-size="10"><i>«part»</i></font>>, margin=0, pos="560,730!", pin=true, width=1.6666666666666667, height=0.8333333333333334, fixedsize=true];
   }
   "n1" -> "n2" [label="supply", arrowhead=none, penwidth=3, pos="400,730 400,730 450,680 450,680 450,680 500,730 500,730"];
 }
@@ -309,7 +337,31 @@ digraph "PlantViews::placedView" {
   node where it is. The names cannot collide with a rendering's `n<i>` node IDs.
 - **Nodes.** A `Layout` names the box's top-left corner; Graphviz positions a node's centre, so
   the writer pins `pos="x,y!"` at the centre of the box and `pin=true` keeps `neato` from
-  moving it. A stated size is `width`/`height` in inches with `fixedsize=true`. Without one
+  moving it. A stated size is `width`/`height` in inches with `fixedsize=true`, and the label
+  is composed to fit it (`dotFittedLabel` in `dot.go`), never the box grown to the label: the
+  node's `margin=0` gives the whole box to the label (Graphviz's default pads it by 0.11 by
+  0.055 in, which a 14 px compartment row cannot spare), the head is word-wrapped at the box's
+  width and drawn at the largest whole font size from 14 pt down to 8 pt at which the wrapped
+  lines stack within the height with every word whole — a word wider than the box at every size
+  is broken where it overruns, at the largest size whose lines then fit; the keyword line (at
+  10/14 of the head's size) and each detail line follow only while height remains for them, so
+  a 449×14 px compartment row holds
+  `<font point-size="11"><b>errorReq : Real</b></font>` and nothing else; a head that overruns the
+  height even at 8 pt is cut to the lines that fit and its last line ellipsized. A stated box
+  that holds other stated boxes — a part whose members are drawn inside it, a definition over
+  its compartment rows — keeps its title clear of them: the label is fitted to the strip between
+  the box's top and the topmost box it encloses and set there with `labelloc=t`, so the title
+  reads as a diagram frame's header and the members below it stay where the Layout put them
+  (`headroom` in `dot.go`; a box that is only placed, and so sized to its own label, is not one
+  the title moves for). A stated box too short for one 8 pt line, or too narrow for one glyph —
+  whether the whole box or the strip its members leave it — holds no text: its head is set
+  outside as `xlabel`, as a symbol's is, and a box with only its kind to show is left bare
+  (`dotStatedLabel`). A stated node drawn as a cluster round its children has its label fitted the
+  same way, to the strip above its topmost stated child; a cluster's label has no outside to go
+  to, so a strip thinner than a line still gets one line at 8 pt. The estimate is
+  the box fitting's own — 0.6 em a glyph (0.66 em bold), 1.2 em a line — so nothing here is
+  particular to the tool that stated the box. A symbol kind in a stated box carries no label at
+  all ([Style](#style)). Without a stated size
   the writer sizes the box to the label itself — 0.6 em a glyph (0.66 em in the bold head),
   1.2 em a line, at 14 pt for every line but the 10 pt keyword line, Graphviz's margins, no
   smaller than its 54×36 pt default box, a circle round the label for a
@@ -336,16 +388,30 @@ digraph "PlantViews::placedView" {
   kind draws takes a route: a connection, binding or flow of an interconnection, a transition
   of a state rendering, a succession or flow of an action rendering — the annotation names the
   member (`metadata DiagramLayout::Route about 'a to b'`), so only a named edge can carry one.
+- **Unplaced nodes.** A node counts as positioned however its box was found — by its
+  `Layout`, round its members, or from a route. When some nodes are positioned and others are
+  not, the drawing shows what its source showed: the unpositioned nodes are left undrawn, with
+  every edge at one of them and the containment edge a tree would draw to it, and a
+  `// not represented:` notice counts them (`2 node(s) without a position, left undrawn, and 1
+  edge(s) at them`), so nothing lands on a placed box — a migrated diagram's members the source
+  diagram never drew stay out of its picture. `Options.Unplaced = UnplacedStrip`
+  (`-render-unplaced strip` at the CLI, for `-render`, `-render-all` and the `dot` diagrams of a
+  document) keeps them instead: each unplaced node not under another unplaced node (every one, in
+  a tree) is boxed as an unpositioned node is — fitted to its label, or as a cluster round its
+  children — and the boxes are packed in rows, left to right, wrapped at the drawing's width,
+  24 px apart and 24 px below the drawing's extent (the canvas when it has one, else the
+  positioned boxes and routes), then pinned like any other; the notice says so. A strip node
+  keeps its place in the text — a member of a positioned cluster is written in that cluster,
+  whose stated box is not stretched to it — so Graphviz draws it below the box it belongs to.
+  A drawing with no positioned node is unchanged by either setting. An `Unplaced` that is
+  neither is refused (`UnknownUnplacedError`).
 - **Engine.** The `// layout:` header names the command that honours what is written:
-  `neato -n2` when every node is positioned and any edge is routed (the pinned nodes and the
-  written routes are taken as given, the other edges are drawn), `neato -n` when every node is
-  positioned and no edge is routed, `neato` when only some nodes are (pinned nodes stay, the
-  rest are placed around them), `dot` when none is. A node counts as positioned however its box
-  was found — by its `Layout`, round its members, or from a route — so a view whose every node
-  is placed or routed is written for `neato -n2`, which refuses a node with no position.
-  `neato` and `dot` redraw every edge, so when the header names either and a route was
-  written, a `// not represented:` notice says so. A rendering with no geometry is written byte
-  for byte as before.
+  `neato -n2` when any edge is routed (the pinned nodes and the written routes are taken as
+  given, the other edges are drawn), `neato -n` when no edge is routed, `dot` when no node is
+  positioned. Every node a positioned drawing draws is pinned, so plain `neato` is never named
+  and `neato -n2`, which refuses a node with no position, always has one for each; a route of
+  two or more waypoints positions its ends, so a written route is always read by `neato -n2`.
+  A rendering with no geometry is written byte for byte as before.
 
 The writer is still text over the tree: no Graphviz binary is run to produce, check or test
 the output.
@@ -534,6 +600,21 @@ and did not change. A view-render RPC added later would take the form as a strin
   and the header's engine for none, some and all of the nodes positioned and all edges routed;
   the syntax check parses every `pos` and `bb` it meets, and reads an HTML-like label as one
   string whose tags balance and whose entities are known.
+- `internal/ir/view/dot_fit_test.go`: the label fitted to a stated box — a head wrapped at the
+  width, kept at 14 pt while it fits and shrunk to 8 pt when it does not, the keyword and detail
+  lines kept only while height remains, a compartment row's one line, a word broken across
+  lines only when no size keeps it whole, the ellipsis at the floor, the title of a box that
+  holds stated boxes fitted to the strip above them and set at the top, an only-placed box
+  leaving it be, a stated cluster's label fitted to its strip, a box or strip too short or
+  narrow for a line setting its head outside — and `dotFitHead`/`dotWrap`
+  on their own; the symbol every kind draws as in a stated box, its `xlabel` for a name and none
+  for a synthesized one, a `port def` and an unsized symbol kind still labelled; an unsized
+  node's label unchanged.
+- `internal/ir/view/label_test.go`: a member headed by its name below its drawn owner, at every
+  depth and for a nested exposed element, an unrelated root left whole, the text form unchanged.
+- `internal/ir/view/bookkeeping_test.go`: a tree over migrated views carries none of their
+  `DiagramLayout` annotations, `SynthesizedName` markers or `render` members, while a user's
+  metadata usage and a rendering usage outside a view are still drawn.
 - `internal/ir/view/dot_style_test.go`, `palette_test.go`: the B&W defaults; a definition
   square and a usage rounded; the pseudo-state rules named and unnamed, placed and not; the
   package, element and region cluster widths; the connection's `penwidth=3`; the family of every
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index 809d42b7c..ffb894520 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -221,6 +221,7 @@ reported, so a script that reads it takes the output from the first `{`.
 | `--render-all <dir>` | | Render every declared view into the directory, one artifact per view |
 | `--render-form <form>` | | Form `--render` or `--render-all` writes: `text`, `mermaid`, `markdown`, `dot` or `plantuml` (default: destination-dependent for `--render`, each kind's machine-readable form for `--render-all`) |
 | `--render-palette <name>` | | Palette the `dot` or `plantuml` form of `--render` or `--render-all` fills nodes with, by keyword family: `okabe-ito`, `tol-bright`, `tol-muted`, `tol-light`, `brewer-set2`, `brewer-dark2`, `viridis` or `cividis`; black and white when absent. Mermaid notes it as not represented; text and Markdown ignore it. An unknown name is refused with the names there are (see [Rendering a view](#rendering-a-view)) |
+| `--render-unplaced <placement>` | | Where the `dot` form of a view some `DiagramLayout::Layout` positions puts the nodes none does: `omit` (the default) leaves them, and the edges at them, undrawn; `strip` draws them in rows below the drawing, clear of the canvas and every positioned box. Applies to `--render`, `--render-all` and the `dot` diagrams of `--render-document` and `--render-documents`; a view with no positioned node is laid out as before whichever is named. An unknown placement is refused with the placements there are (see [Rendering a view](#rendering-a-view)) |
 | `--render-document <name>` | | Compile a document definition (a `part def` specializing `DocumentQueries::Document`), run its queries against the model, render its diagram blocks through the view engine and write the result as CommonMark Markdown, as `%render-document` does. Paragraphs may hold inline runs (`Span` with a `plain`/`emphasis`/`strong`/`code` style, `Link` to a URL, `Ref` linking to another content block's anchor); a query-backed paragraph or list styles its projected values through nested `SpanColumn`/`LinkColumn` column runs; a table with a `groupBy` column writes one subtable per group value, with the query's projected properties and computed `Column` names as its columns. A `Diagram` block embeds a declared view, or an element with a stated rendering kind, as a fenced ` ```mermaid ` block (a fenced ` ```dot ` block of Graphviz DOT under `-diagram-form dot`, a ` ```plantuml ` block under `-diagram-form plantuml`; a table-kind view as a pipe table whichever form), with an optional caption and `TB`/`LR`/`RL`/`BT` flow direction. Markdown is the default form; `-doc-form html` renders the same document tree as semantic HTML (see [Rendering a document as HTML](#rendering-a-document-as-html)) and `-doc-form pdf` converts the Markdown (see [Rendering a document as PDF](#rendering-a-document-as-pdf)). Combined with `--instantiate`, the document's queries run over the objects created (see [Rendering a document over objects](#rendering-a-document-over-objects)). `-json` does not apply. See the [document generation manual](../manual/README.md) |
 | `--doc-form <form>` | | Form `--render-document` writes: `markdown` (default), `html`, rendered from the document tree itself (see [Rendering a document as HTML](#rendering-a-document-as-html)), or `pdf`, which drives an external converter |
 | `--diagram-form <form>` | | Form the graph-shaped diagram blocks of `--render-document` and `--render-documents` are written in: `mermaid` (default), `dot`, Graphviz DOT for a toolchain that lays diagrams out with Graphviz, produced without Graphviz installed, or `plantuml`, PlantUML in the Pilot visualizer's B&W style, produced without a PlantUML jar. Applies to every diagram of the document in every `--doc-form`; a table-kind view is a table whichever form, and a `sequence` diagram, which has no DOT form, is refused under `dot` |
@@ -456,6 +457,7 @@ sysml model.sysml -render Views::vehicleView -render-form text
 # Graphviz DOT for a graph-shaped kind, to lay out with dot(1) or any Graphviz-reading tool
 sysml model.sysml -render Views::vehicleView -render-form dot -o view.dot
 sysml model.sysml -render Views::vehicleView -render-form dot -render-palette okabe-ito -o view.dot
+sysml model.sysml -render Views::vehicleView -render-form dot -render-unplaced strip -o view.dot
 
 # PlantUML in the Pilot visualizer's B&W style, for a PlantUML toolchain; no jar is run
 sysml model.sysml -render Views::vehicleView -render-form plantuml -o view.puml
@@ -641,14 +643,21 @@ y=80 w=200 h=90`, `%% route: n1->n2 320,125 400,125`) and the text form appends
 honours it: a positioned node is pinned at the centre of its box (`pos="220,675!", pin=true`, in
 points with y measured up from the canvas's bottom edge — negated when no canvas height is
 stated — one pixel to one point under `inputscale=72`), a stated size is `width`/`height` in inches
-with `fixedsize=true` (an unstated one is fitted to the label, so the box's corner stays put), a
+with `fixedsize=true` and the label fitted to it — the name wrapped at the width and shrunk from
+14 pt to 8 pt until it fits, the keyword and detail lines kept only while height remains, and a
+decision, fork, initial, final or port drawn as its symbol with the name beside it (an unstated
+size is fitted to the label, so the box's corner stays put), a
 positioned cluster states its `bb`, a route is the edge's `pos` spline (a route of one waypoint
 draws no line and is noticed), the canvas is echoed as `// canvas:` and held by an invisible
 point pinned at each corner so the drawing's bounding box is the canvas, and the
-`// layout:` header names the command that honours it — `neato -n2` when every node is placed
-and any edge routed, `neato -n` when every node is placed and none routed, `neato` when only
-some nodes are — so `neato -n2 -Tsvg view.dot` draws the view where the model put it. `neato`
-redraws every edge, so under it a written route is noticed as redrawn.
+`// layout:` header names the command that honours it — `neato -n2` when any edge is routed,
+`neato -n` when none is — so `neato -n2 -Tsvg view.dot` draws the view where the model put it.
+A node the model does not position, in a view that positions others, is left undrawn with
+the edges at it — a migrated diagram shows what its source showed, and nothing lands on a
+placed box — and a `// not represented:` notice counts what was left out;
+`-render-unplaced strip` draws those nodes instead, in rows below the canvas or the positioned
+boxes, wrapped at the drawing's width and clear of it and of one another. Either way every node
+drawn is pinned, so `neato` is never left to place one.
 A model with no layout annotations renders exactly as before. `-validate` reports a `Layout` or
 `Route` on an element the rendering does not draw as a node or an edge, a `Route` with an odd
 number of values, a `Canvas` outside a view, and two positions for one element in one view (the
diff --git a/docs/reference/grammar/README.md b/docs/reference/grammar/README.md
index cf09e49f8..d289138d8 100644
--- a/docs/reference/grammar/README.md
+++ b/docs/reference/grammar/README.md
@@ -114,7 +114,7 @@ Notes:
 
 Grammar conformance is validated by parsing **OMG's own files**:
 
-1. **Stdlib conformance gate** - all 104 bundled library files (94 OMG standard library files and 10 OpenSysML extensions) must parse with zero diagnostics
+1. **Stdlib conformance gate** - all 106 bundled library files (94 OMG standard library files and 12 OpenSysML extensions) must parse with zero diagnostics
    - See: `internal/workspace/libs/stdlib_conformance_test.go`
    - These files are the **source of truth** for correct parsing
 
diff --git a/docs/reference/lsp.md b/docs/reference/lsp.md
index 59b476a1d..b3370781a 100644
--- a/docs/reference/lsp.md
+++ b/docs/reference/lsp.md
@@ -175,6 +175,7 @@ The result, for `{"view": "KitViews::widgetTree"}` over a document declaring
 | `owners` | On a node with an `fqn`: the namespaces declaring it, nearest first, each as its `fqn` and whether it is a `feature`, whether or not the view draws them. A client writes a connection into the nearest owner two nodes share, or into the document when they share none, and spells each end from there — through a feature by `.`, into any other namespace by `::` (`tank.fuelOut`, `Car::tank.fuelOut`). Absent for a top-level declaration. |
 | `palette` | What a diagram of this kind offers to add, in the document's language: `members` are member kinds for `applyModelEdit`'s `addMember`, `connections` are connection kinds for `addConnection`, `typed` are the `members` that may be given a `type`, and `owners` lists, for each member only some bodies declare (`subject`, `actor`, `stakeholder` in a requirement or case, `objective` in a case), the ids of the nodes whose declaration opens such a body — a client offers such a member on those nodes alone, and a member absent from `owners` on every declared node. The same admission decides where a node may be moved: `owners` also lists, under the `notation` of each drawn node that only some bodies declare (`entry action`, `subject`), the nodes that admit it, so a client offers as the new owner of a node the declared nodes, and the document, that its `notation` finds in `owners` — or every one when it is absent. An `interconnection` offers parts, ports, items, attributes and the connection kinds; a `state` diagram states and transitions; an `action` or `sequence` diagram actions, control nodes and successions; a `tree` every kind the language has. Absent for a kind that is not edited from a diagram — a `table`, whose rows name no owner or endpoint to act on, included. |
 | `fill`, `border` | On a node, when the request named a `palette`: the `#RRGGBB` colours the palette gives the node's box and its outline, the same the DOT and PlantUML forms draw it with — a definition its keyword family's colour, a usage a lighter tint of it, both lightened until black text reads on them. A `sequence` participant carries `fill` alone, PlantUML taking no border colour on one. Absent for a node the palette leaves black and white — a control node, a container drawn around its children (a `tree` fills those too, drawing containment as edges) — and for every node when no palette was named. A server that does not advertise `openSysmlRenderPalette` never sends them. |
+| `nameSynthesized` | On a node: `true` when the model did not give the `name`: a migration made it up for an element its source left unnamed (`MigrationMetadata::SynthesizedName`), or it is the language's own `start` or `done` of an action's flow. Such a name keys the node but a diagram does not show it — the DOT form draws the node unnamed, a control node as its bare symbol. Absent otherwise. An edge whose only text would be such a name carries no `label`, as one the source left unnamed. |
 | `x`, `y`, `width`, `height`, `collapsed` | On a node: where the model places it, from a `DiagramLayout::Layout` annotation, in pixels from the canvas's top-left corner with y increasing downward. Absent for a node the model does not place; `width` and `height` only when the annotation sizes it; `collapsed` only when it says so. |
 | `route` | On an edge: the waypoints a `DiagramLayout::Route` annotation gives it, as an array of `{"x", "y"}` in the same coordinates. Absent for an edge with none. |
 | `canvas` | The drawing surface the view states with a `DiagramLayout::Canvas` annotation: its `unit` when given, and `width` and `height` together when the annotation sizes it (an explicit `0` is a size). Absent for a view stating none and for every pseudo-view. |
diff --git a/docs/reference/sysml-v1-migration.md b/docs/reference/sysml-v1-migration.md
index 2624d93cd..32b9eaa6e 100644
--- a/docs/reference/sysml-v1-migration.md
+++ b/docs/reference/sysml-v1-migration.md
@@ -749,6 +749,18 @@ becomes is one the state debugger steps. Every generated model is gated to analy
 the migration tests execute a generated activity and a generated state machine, not only parse
 them.
 
+Every name the migration makes up because the source had none — an edge's spelling from its
+ends, a node's kind made unique (`decide`, `fork2`, `final`), the `unnamed` and typed-after-type
+refs, an anonymous end named for its type — is recorded in the body it is written in, once per
+body, as `metadata MigrationMetadata::SynthesizedName about 'start to call', 'fork', final;`
+(`$::MigrationMetadata::` where a member shadows the library). The names stay as written and
+keyed by — an `expose`, a route, a qualified name all reach them — and what reads the model can
+tell them from names the source gave: the [graphical renderings](../project/view-rendering-forms.md#node-labels)
+draw such an element as its source did, unnamed — a bare control-node symbol, an edge with no
+label — and every other name as it is. `MigrationMetadata` is a bundled OpenSysML library, not a
+standard one; a v1 name is never marked, however it was spelled, and a model whose bodies hold
+no made-up name gains no line.
+
 **Activities.** The nodes are written first, then the edges. A node's name is its v1 name when
 it has one, else its kind (`call`, `decide`, `fork`, …) made unique within the activity. A
 call action is `action call : Def;`, so the callee's flow runs as a nested performance; its pins
diff --git a/examples/self-model/pipeline.sysml b/examples/self-model/pipeline.sysml
index 3b1d41a8f..beda5f879 100644
--- a/examples/self-model/pipeline.sysml
+++ b/examples/self-model/pipeline.sysml
@@ -334,7 +334,7 @@ package OpenSysMLPipeline {
     // snapshot when that matches the files, and parsed from the files otherwise.
     #SemanticEngine part def StandardLibrary :> Stage {
         attribute :>> goPackage = "internal/workspace/libs";
-        attribute bundledFileCount : Integer = 105;
+        attribute bundledFileCount : Integer = 106;
         attribute cached : Boolean = true;
         attribute snapshotFile : String = "internal/workspace/libs/stdlib.snapshot";
         attribute snapshotEmbedded : Boolean = true;
diff --git a/examples/self-model/quality.sysml b/examples/self-model/quality.sysml
index 01dfa4ab1..43df59985 100644
--- a/examples/self-model/quality.sysml
+++ b/examples/self-model/quality.sysml
@@ -71,7 +71,7 @@ package OpenSysMLInvariants {
         doc /* Every bundled standard library file parses clean. */
         subject stdlib : StandardLibrary;
         require constraint {
-            stdlib.bundledFileCount == 105
+            stdlib.bundledFileCount == 106
         }
     }
 
diff --git a/internal/doc/docpdf/diagrams_test.go b/internal/doc/docpdf/diagrams_test.go
index 69a98e4ea..edce20745 100644
--- a/internal/doc/docpdf/diagrams_test.go
+++ b/internal/doc/docpdf/diagrams_test.go
@@ -61,7 +61,7 @@ func fakeJar(t *testing.T, dir string) string {
 // telescopeDiagrams lists the telescope report's two diagrams written in form.
 func telescopeDiagrams(t *testing.T, form view.Form) []docrender.Diagram {
 	t.Helper()
-	diagrams, err := docrender.Diagrams(telescopeDocument(t), form)
+	diagrams, err := docrender.Diagrams(telescopeDocument(t), form, "")
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/internal/doc/docpdf/docpdf.go b/internal/doc/docpdf/docpdf.go
index fa7f451b0..ba8dfa648 100644
--- a/internal/doc/docpdf/docpdf.go
+++ b/internal/doc/docpdf/docpdf.go
@@ -48,6 +48,10 @@ type Options struct {
 	// DiagramForm is the source graph-shaped diagrams are drawn from, Mermaid
 	// when empty.
 	DiagramForm view.Form
+
+	// Unplaced is where a DOT diagram some Layout positions puts the nodes
+	// none does: left undrawn when empty, or in a strip below the drawing.
+	Unplaced view.Unplaced
 }
 
 // PrintStylesheet is the PDF backend's print stylesheet: page geometry, the
@@ -78,7 +82,7 @@ func Render(document *docir.Document, engine string, opts Options) ([]byte, erro
 	if err := converter.Available(); err != nil {
 		return nil, err
 	}
-	diagrams, err := docrender.Diagrams(document, opts.DiagramForm)
+	diagrams, err := docrender.Diagrams(document, opts.DiagramForm, opts.Unplaced)
 	if err != nil {
 		return nil, err
 	}
@@ -104,7 +108,7 @@ func Render(document *docir.Document, engine string, opts Options) ([]byte, erro
 	doc := &Prepared{Dir: dir, MathCSS: math.css, BaseDir: base, Options: opts}
 	switch converter.Capabilities().Input {
 	case InputMarkdown:
-		markdown, err := docrender.Markdown(document, docrender.MarkdownOptions{DiagramForm: opts.DiagramForm})
+		markdown, err := docrender.Markdown(document, docrender.MarkdownOptions{DiagramForm: opts.DiagramForm, Unplaced: opts.Unplaced})
 		if err != nil {
 			return nil, err
 		}
@@ -172,6 +176,7 @@ func htmlOptions(opts Options, dir string, images []string, math formulas) docre
 		NumberSections:      opts.NumberSections,
 		Lang:                opts.Lang,
 		DiagramForm:         opts.DiagramForm,
+		Unplaced:            opts.Unplaced,
 		DiagramImages:       images,
 		Math:                math.html,
 	}
diff --git a/internal/doc/docpdf/integration_test.go b/internal/doc/docpdf/integration_test.go
index d6a12a194..6c455157d 100644
--- a/internal/doc/docpdf/integration_test.go
+++ b/internal/doc/docpdf/integration_test.go
@@ -362,7 +362,7 @@ func TestRenderDiagramsWithInstalledGraphviz(t *testing.T) {
 		skipWithout(t, "Graphviz dot", err)
 	}
 	dir := t.TempDir()
-	diagrams, err := docrender.Diagrams(telescopeDocument(t), view.FormDot)
+	diagrams, err := docrender.Diagrams(telescopeDocument(t), view.FormDot, "")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -424,7 +424,7 @@ func TestRenderDiagramsWithInstalledPlantUML(t *testing.T) {
 		skipWithout(t, "java", err)
 	}
 	dir := t.TempDir()
-	diagrams, err := docrender.Diagrams(telescopeDocument(t), view.FormPlantUML)
+	diagrams, err := docrender.Diagrams(telescopeDocument(t), view.FormPlantUML, "")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -475,8 +475,9 @@ func TestRenderWideTableLandscapeWithInstalledEngines(t *testing.T) {
 
 // TestRenderTallFigureFitsThePageWithInstalledEngines renders a forty-step
 // action flow through each installed converter with mermaid-cli and reads back
-// that the figure is scaled onto one page, its first and last node and its
-// caption together, rather than cut at the page's foot.
+// that the figure is scaled onto one page, its first node (the language's
+// `start`, headed as `initial`) and last step and its caption together, rather
+// than cut at the page's foot.
 func TestRenderTallFigureFitsThePageWithInstalledEngines(t *testing.T) {
 	if _, err := mermaidTool.locate(""); err != nil {
 		skipWithout(t, "mmdc", err)
@@ -491,7 +492,7 @@ func TestRenderTallFigureFitsThePageWithInstalledEngines(t *testing.T) {
 				}
 			}
 			for _, page := range strings.Split(text, "\f") {
-				if strings.Contains(page, "start") && strings.Contains(page, "step40") && strings.Contains(page, "Forty steps in a column") {
+				if strings.Contains(page, "initial") && strings.Contains(page, "step40") && strings.Contains(page, "Forty steps in a column") {
 					return
 				}
 			}
diff --git a/internal/doc/docrender/artwork.go b/internal/doc/docrender/artwork.go
index 4554544a7..99402b1bf 100644
--- a/internal/doc/docrender/artwork.go
+++ b/internal/doc/docrender/artwork.go
@@ -20,9 +20,10 @@ type Diagram struct {
 }
 
 // Diagrams lists the document's graph-shaped diagrams in document order, each
-// with the source the backends write for it in form (Mermaid when empty). A
-// table-kind view is a table, not a diagram, and is left out.
-func Diagrams(document *docir.Document, form view.Form) ([]Diagram, error) {
+// with the source the backends write for it in form (Mermaid when empty) with
+// unplaced nodes placed as unplaced says. A table-kind view is a table, not a
+// diagram, and is left out.
+func Diagrams(document *docir.Document, form view.Form, unplaced view.Unplaced) ([]Diagram, error) {
 	if document == nil {
 		return nil, &Error{Kind: ErrorNilDocument}
 	}
@@ -50,7 +51,7 @@ func Diagrams(document *docir.Document, form view.Form) ([]Diagram, error) {
 			if !rendering.Kind.Supported() {
 				return &Error{Kind: ErrorUnrenderableDiagram, Content: node.Name(), Actual: string(rendering.Kind)}
 			}
-			source, err := diagramSource(node.Name(), rendering, node.Options(), resolved)
+			source, err := diagramSource(node.Name(), rendering, figureOptions(node, unplaced), resolved)
 			if err != nil {
 				return err
 			}
diff --git a/internal/doc/docrender/artwork_test.go b/internal/doc/docrender/artwork_test.go
index b0d0bea0f..70b31e5a3 100644
--- a/internal/doc/docrender/artwork_test.go
+++ b/internal/doc/docrender/artwork_test.go
@@ -21,7 +21,7 @@ const (
 func TestDiagramsListGraphShapedViews(t *testing.T) {
 	document := fixtureDocument(t, filepath.Join("testdata", telescopeFixture), "Observatory::MassReport")
 	for _, form := range []view.Form{"", view.FormMermaid, view.FormDot} {
-		diagrams, err := Diagrams(document, form)
+		diagrams, err := Diagrams(document, form, "")
 		if err != nil {
 			t.Fatalf("Diagrams(%q): %v", form, err)
 		}
@@ -42,11 +42,11 @@ func TestDiagramsListGraphShapedViews(t *testing.T) {
 
 func TestDiagramsErrors(t *testing.T) {
 	var typed *Error
-	if _, err := Diagrams(nil, ""); !errors.As(err, &typed) || typed.Kind != ErrorNilDocument {
+	if _, err := Diagrams(nil, "", ""); !errors.As(err, &typed) || typed.Kind != ErrorNilDocument {
 		t.Errorf("nil document: %v", err)
 	}
 	document := fixtureDocument(t, filepath.Join("testdata", telescopeFixture), "Observatory::MassReport")
-	if _, err := Diagrams(document, "svg"); !errors.As(err, &typed) || typed.Kind != ErrorUnknownForm {
+	if _, err := Diagrams(document, "svg", ""); !errors.As(err, &typed) || typed.Kind != ErrorUnknownForm {
 		t.Errorf("unknown form: %v", err)
 	}
 }
diff --git a/internal/doc/docrender/html.go b/internal/doc/docrender/html.go
index 94417e545..c26593699 100644
--- a/internal/doc/docrender/html.go
+++ b/internal/doc/docrender/html.go
@@ -144,6 +144,10 @@ type HTMLOptions struct {
 	// Mermaid when empty; a table-kind view is a table whichever it is.
 	DiagramForm view.Form
 
+	// Unplaced is where a DOT diagram some Layout positions puts the nodes
+	// none does: left undrawn when empty, or in a strip below the drawing.
+	Unplaced view.Unplaced
+
 	// DiagramImages are images drawn ahead of the render, one per graph-shaped
 	// diagram in the order Diagrams lists them, each written as <img> in place
 	// of its source; an empty entry, or none, keeps the source. More entries
@@ -626,7 +630,7 @@ func displayMathHTML(source string) string {
 // or else as its source in the render's diagram form — Mermaid, which a loaded
 // Mermaid script draws, or DOT or PlantUML — shown as text.
 func (w *htmlWriter) writeDiagram(node docir.Content, id string) error {
-	return w.writeFigure(id, node.Name(), node.Caption(), node.Rendering(), node.Options())
+	return w.writeFigure(id, node.Name(), node.Caption(), node.Rendering(), figureOptions(node, w.opts.Unplaced))
 }
 
 func (w *htmlWriter) writeFigure(id, name, caption string, rendering *view.Rendering, options view.Options) error {
diff --git a/internal/doc/docrender/markdown.go b/internal/doc/docrender/markdown.go
index 806ed70d0..3dfec44d8 100644
--- a/internal/doc/docrender/markdown.go
+++ b/internal/doc/docrender/markdown.go
@@ -23,6 +23,10 @@ type MarkdownOptions struct {
 	// DiagramForm is the source every graph-shaped diagram is written as,
 	// Mermaid when empty; a table-kind view is a pipe table whichever it is.
 	DiagramForm view.Form
+
+	// Unplaced is where a DOT diagram some Layout positions puts the nodes
+	// none does: left undrawn when empty, or in a strip below the drawing.
+	Unplaced view.Unplaced
 }
 
 // Markdown renders an evaluated document as deterministic CommonMark: the
@@ -42,7 +46,7 @@ func Markdown(document *docir.Document, opts MarkdownOptions) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	w := &markdownWriter{form: form}
+	w := &markdownWriter{form: form, unplaced: opts.Unplaced}
 	var blocks []string
 	blocks = append(blocks, heading(1, document.Title()))
 	for _, node := range document.Content() {
@@ -70,7 +74,16 @@ func diagramForm(form view.Form) (view.Form, error) {
 // markdownWriter carries the choices one Markdown render applies to every
 // node it writes.
 type markdownWriter struct {
-	form view.Form
+	form     view.Form
+	unplaced view.Unplaced
+}
+
+// figureOptions is what a diagram's rendering is written with: its stated
+// direction and palette, and the render's placement of unplaced nodes.
+func figureOptions(node docir.Content, unplaced view.Unplaced) view.Options {
+	options := node.Options()
+	options.Unplaced = unplaced
+	return options
 }
 
 // renderContent renders one content node, with level the ATX heading level a
@@ -110,7 +123,7 @@ func (w *markdownWriter) renderNode(node docir.Content, level int) ([]string, er
 	case docir.ContentFormula:
 		return renderFormula(node), nil
 	case docir.ContentDiagram:
-		return diagramBlocks(node.Name(), node.Caption(), node.Rendering(), node.Options(), w.form)
+		return diagramBlocks(node.Name(), node.Caption(), node.Rendering(), figureOptions(node, w.unplaced), w.form)
 	default:
 		return nil, &Error{Kind: ErrorUnknownContent, Content: node.Name(), Actual: string(node.Kind())}
 	}
@@ -184,8 +197,9 @@ func diagramBlocks(name, caption string, rendering *view.Rendering, options view
 }
 
 // diagramSource writes a graph-shaped rendering in the resolved diagram form
-// with the diagram's direction and palette, without its trailing newline. A
-// Mermaid chart past the size a chart is drawn under is refused, not written.
+// with the diagram's direction, palette and placement of unplaced nodes,
+// without its trailing newline. A Mermaid chart past the size a chart is drawn
+// under is refused, not written.
 func diagramSource(name string, rendering *view.Rendering, options view.Options, form view.Form) (string, error) {
 	if !rendering.Kind.SupportsForm(form) {
 		return "", &Error{Kind: ErrorUnrenderableForm, Content: name, Actual: string(rendering.Kind), DiagramForm: form}
diff --git a/internal/doc/docrender/testdata/placed_report.sysml b/internal/doc/docrender/testdata/placed_report.sysml
new file mode 100644
index 000000000..0a84cefde
--- /dev/null
+++ b/internal/doc/docrender/testdata/placed_report.sysml
@@ -0,0 +1,40 @@
+package Placed {
+	private import DocumentQueries::*;
+	private import DiagramLayout::*;
+	private import Views::*;
+
+	port def DataPort;
+
+	part def Camera {
+		port output : DataPort;
+	}
+
+	part def Recorder {
+		port input : DataPort;
+	}
+
+	part imagingChain {
+		part camera : Camera;
+		part recorder : Recorder;
+		part spare : Recorder;
+		connection link connect camera.output to recorder.input;
+	}
+
+	// Positions two of the three parts; spare is left unplaced.
+	view placedView {
+		expose imagingChain;
+		render asInterconnectionDiagram;
+		@Canvas { unit = "px"; width = 400; height = 200; }
+		metadata Layout about imagingChain::camera { x = 20; y = 40; width = 120; height = 60; }
+		metadata Layout about imagingChain::recorder { x = 220; y = 40; width = 120; height = 60; }
+	}
+
+	part def PlacedReport :> Document {
+		attribute redefines title = "Placed report";
+
+		part chain : Diagram {
+			attribute redefines caption = "Imaging chain, as laid out";
+			ref redefines source = placedView;
+		}
+	}
+}
diff --git a/internal/doc/docrender/unplaced_test.go b/internal/doc/docrender/unplaced_test.go
new file mode 100644
index 000000000..e4676e89f
--- /dev/null
+++ b/internal/doc/docrender/unplaced_test.go
@@ -0,0 +1,73 @@
+package docrender
+
+import (
+	"html"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+)
+
+// TestDocumentDiagramsSettleUnplacedNodes checks the unplaced-node placement
+// reaches every document backend's DOT figures: the Markdown fence, the HTML
+// figure and the artwork source a PDF draws leave a node no Layout places
+// undrawn by default and set it in a strip below the drawing when asked.
+func TestDocumentDiagramsSettleUnplacedNodes(t *testing.T) {
+	document := fixtureDocument(t, filepath.Join("testdata", "placed_report.sysml"), "Placed::PlacedReport")
+	const (
+		omitted = "// not represented: 1 node(s) without a position, left undrawn\n"
+		striped = "// not represented: 1 node(s) without a position, drawn in a strip below the drawing\n"
+		spare   = "<b>spare : Recorder</b>"
+	)
+	check := func(t *testing.T, backend, got string, unplaced view.Unplaced) {
+		t.Helper()
+		notice, drawn := omitted, false
+		if unplaced == view.UnplacedStrip {
+			notice, drawn = striped, true
+		}
+		if !strings.Contains(got, notice) {
+			t.Errorf("%s (%q): notice %q missing:\n%s", backend, unplaced, notice, got)
+		}
+		if strings.Contains(got, spare) != drawn {
+			t.Errorf("%s (%q): spare drawn = %v, want %v:\n%s", backend, unplaced, !drawn, drawn, got)
+		}
+		if !strings.Contains(got, "// layout: neato -n\n") {
+			t.Errorf("%s (%q): every drawn node is pinned, so the header names neato -n:\n%s", backend, unplaced, got)
+		}
+	}
+	for _, unplaced := range []view.Unplaced{"", view.UnplacedOmit, view.UnplacedStrip} {
+		markdown, err := Markdown(document, MarkdownOptions{DiagramForm: view.FormDot, Unplaced: unplaced})
+		if err != nil {
+			t.Fatalf("Markdown(%q): %v", unplaced, err)
+		}
+		check(t, "markdown", markdown, unplaced)
+		page, err := HTML(document, HTMLOptions{DiagramForm: view.FormDot, Unplaced: unplaced})
+		if err != nil {
+			t.Fatalf("HTML(%q): %v", unplaced, err)
+		}
+		check(t, "html", html.UnescapeString(page), unplaced)
+		diagrams, err := Diagrams(document, view.FormDot, unplaced)
+		if err != nil {
+			t.Fatalf("Diagrams(%q): %v", unplaced, err)
+		}
+		if len(diagrams) != 1 {
+			t.Fatalf("Diagrams(%q) = %+v, want the one figure", unplaced, diagrams)
+		}
+		check(t, "artwork", diagrams[0].Source+"\n", unplaced)
+	}
+	for _, backend := range []string{"markdown", "html", "artwork"} {
+		var err error
+		switch backend {
+		case "markdown":
+			_, err = Markdown(document, MarkdownOptions{DiagramForm: view.FormDot, Unplaced: "below"})
+		case "html":
+			_, err = HTML(document, HTMLOptions{DiagramForm: view.FormDot, Unplaced: "below"})
+		default:
+			_, err = Diagrams(document, view.FormDot, "below")
+		}
+		if err == nil || !strings.Contains(err.Error(), `unknown placement "below"`) {
+			t.Errorf("%s: an unknown placement is not refused: %v", backend, err)
+		}
+	}
+}
diff --git a/internal/frontend/lsp/render.go b/internal/frontend/lsp/render.go
index e6647afc4..798e31877 100644
--- a/internal/frontend/lsp/render.go
+++ b/internal/frontend/lsp/render.go
@@ -93,25 +93,26 @@ type renderResult struct {
 // `#RRGGBB` colours the palette gives the node, as the DOT and PlantUML forms draw it; absent
 // for a node left black and white, and for every node when no palette is asked for.
 type renderNode struct {
-	ID           string          `json:"id"`
-	Kind         string          `json:"kind"`
-	Name         string          `json:"name"`
-	Type         string          `json:"type"`
-	Detail       string          `json:"detail"`
-	Parent       string          `json:"parent,omitempty"`
-	Fill         string          `json:"fill,omitempty"`
-	Border       string          `json:"border,omitempty"`
-	FQN          string          `json:"fqn,omitempty"`
-	DeclaredHere bool            `json:"declaredHere,omitempty"`
-	Notation     string          `json:"notation,omitempty"`
-	Owners       []renderOwner   `json:"owners,omitempty"`
-	Declaration  *protocol.Range `json:"declaration,omitempty"`
-	Origin       *renderOrigin   `json:"origin,omitempty"`
-	X            *float64        `json:"x,omitempty"`
-	Y            *float64        `json:"y,omitempty"`
-	Width        *float64        `json:"width,omitempty"`
-	Height       *float64        `json:"height,omitempty"`
-	Collapsed    bool            `json:"collapsed,omitempty"`
+	ID              string          `json:"id"`
+	Kind            string          `json:"kind"`
+	Name            string          `json:"name"`
+	NameSynthesized bool            `json:"nameSynthesized,omitempty"`
+	Type            string          `json:"type"`
+	Detail          string          `json:"detail"`
+	Parent          string          `json:"parent,omitempty"`
+	Fill            string          `json:"fill,omitempty"`
+	Border          string          `json:"border,omitempty"`
+	FQN             string          `json:"fqn,omitempty"`
+	DeclaredHere    bool            `json:"declaredHere,omitempty"`
+	Notation        string          `json:"notation,omitempty"`
+	Owners          []renderOwner   `json:"owners,omitempty"`
+	Declaration     *protocol.Range `json:"declaration,omitempty"`
+	Origin          *renderOrigin   `json:"origin,omitempty"`
+	X               *float64        `json:"x,omitempty"`
+	Y               *float64        `json:"y,omitempty"`
+	Width           *float64        `json:"width,omitempty"`
+	Height          *float64        `json:"height,omitempty"`
+	Collapsed       bool            `json:"collapsed,omitempty"`
 }
 
 // renderOwner is a namespace declaring a node: its qualified name, and whether
@@ -324,14 +325,15 @@ func (s *Server) renderNodes(out *renderResult, snapshot *model.Snapshot, nodes
 	var declared []declaredNode
 	for _, node := range nodes {
 		n := renderNode{
-			ID:     node.ID,
-			Kind:   node.Kind,
-			Name:   node.Name,
-			Type:   node.Type,
-			Detail: node.Detail,
-			Parent: node.Parent,
-			Fill:   fills[node.ID].Fill,
-			Border: fills[node.ID].Border,
+			ID:              node.ID,
+			Kind:            node.Kind,
+			Name:            node.Name,
+			NameSynthesized: node.NameSynthesized,
+			Type:            node.Type,
+			Detail:          node.Detail,
+			Parent:          node.Parent,
+			Fill:            fills[node.ID].Fill,
+			Border:          fills[node.ID].Border,
 		}
 		declaring := s.declaring(snapshot, node.Origin)
 		n.Origin = s.originOf(declaring, node.Origin)
diff --git a/internal/ir/lower/state_graph.go b/internal/ir/lower/state_graph.go
index 2653269b8..4b34ddee4 100644
--- a/internal/ir/lower/state_graph.go
+++ b/internal/ir/lower/state_graph.go
@@ -1087,8 +1087,9 @@ func isParallelRegionMember(member ast.Node) bool {
 
 // parallelOwnedMember reports whether a parallel state may own a member itself
 // rather than contribute it to a region: its behaviors, its deferred events, the
-// pseudostates its regions branch through, the edges between them, and a
-// definition written in its body, which declares a type rather than a region.
+// pseudostates its regions branch through, the edges between them, a metadata
+// usage annotating it, and a definition written in its body, which declares a
+// type rather than a region.
 func parallelOwnedMember(member ast.Node) bool {
 	switch n := member.(type) {
 	case *ast.Comment, *ast.Documentation, *ast.TextualRepresentation,
@@ -1099,7 +1100,7 @@ func parallelOwnedMember(member ast.Node) bool {
 		return true
 	case *ast.Usage:
 		switch n.Kind {
-		case ast.UsageAttribute, ast.UsagePort, ast.UsageSuccession:
+		case ast.UsageAttribute, ast.UsagePort, ast.UsageSuccession, ast.UsageMetadata:
 			return true
 		}
 		return IsTerminateUsage(n)
diff --git a/internal/ir/lower/state_graph_nested_test.go b/internal/ir/lower/state_graph_nested_test.go
index 7e7d4f214..0c32a8242 100644
--- a/internal/ir/lower/state_graph_nested_test.go
+++ b/internal/ir/lower/state_graph_nested_test.go
@@ -304,6 +304,27 @@ func TestToStateGraph_ParallelBodyNonRegionMembers(t *testing.T) {
 		}
 	})
 
+	t.Run("metadata is not a region", func(t *testing.T) {
+		graph, err := ToStateGraph(stateUsageIn(t, `
+			package test {
+				metadata def Reviewed;
+				state Machine parallel {
+					state left {
+						entry; then idle;
+						state idle;
+					}
+					metadata Reviewed about left;
+				}
+			}
+		`), nil)
+		if err != nil {
+			t.Fatalf("parallel state with metadata: %v", err)
+		}
+		if len(graph.TopRegions) != 1 || graph.TopRegions[0].Name != "left" {
+			t.Fatalf("parallel regions = %v, want only left (not metadata)", graph.TopRegions)
+		}
+	})
+
 	t.Run("perform is rejected", func(t *testing.T) {
 		_, err := ToStateGraph(stateUsageIn(t, `
 			package test {
diff --git a/internal/ir/view/behavior.go b/internal/ir/view/behavior.go
index 5191257e8..949859d69 100644
--- a/internal/ir/view/behavior.go
+++ b/internal/ir/view/behavior.go
@@ -41,12 +41,13 @@ func (r *Renderer) renderStates(view *symbols.Symbol, exposed []*symbols.Symbol,
 // nested nodes, the start of each body with the entry transitions out of it, and
 // its transitions as edges.
 func (r *Renderer) stateMachineNode(view, machine *symbols.Symbol, graph *lower.StateGraph, ids *nodeIDs, out *Rendering) *Node {
-	root := &Node{ID: ids.take(), Kind: declKind(machine), Name: r.notationName(machine), Type: declType(machine),
-		Origin: symbolOrigin(machine), Inherited: inheritedOrigins(graph.Inherited()), Geometry: r.geometryOf(view, machine, out)}
+	root := &Node{ID: ids.take(), Kind: declKind(machine), Name: r.notationName(machine), NameSynthesized: r.model.NameSynthesized(machine),
+		Type: declType(machine), Origin: symbolOrigin(machine), Inherited: inheritedOrigins(graph.Inherited()), Geometry: r.geometryOf(view, machine, out)}
 	nodes := map[ast.Node]*Node{}
 	regions := map[*ast.StateRegion]*Node{}
 	place := func(node *Node, decl ast.Node) *Node {
 		node.Geometry = r.declaredGeometryOf(view, machine, decl, out)
+		node.NameSynthesized = r.declaredNameSynthesized(machine, decl)
 		return node
 	}
 
@@ -155,12 +156,16 @@ func (r *Renderer) transitionEdges(view, machine *symbols.Symbol, graph *lower.S
 		}
 		doc := docOf(graph, transition.Decl, machine.DocName)
 		out.Edges = append(out.Edges, Edge{
-			From: nodes[src].ID, To: target.ID, Label: r.transitionLabel(doc, transition), Kind: EdgeTransition,
-			Origin: nodeOrigin(doc, transition.Decl), Route: r.declaredRouteOf(view, machine, transition.Decl, out),
+			From: nodes[src].ID, To: target.ID, Label: r.transitionLabel(doc, transition, r.declaredNameSynthesized(machine, transition.Decl)),
+			Kind: EdgeTransition, Origin: nodeOrigin(doc, transition.Decl), Route: r.declaredRouteOf(view, machine, transition.Decl, out),
 		})
 	}
 }
 
+// terminateKind is the Kind of a terminate action usage (`action final terminate;`),
+// the activity's final node, drawn as the final symbol when a box places it.
+const terminateKind = "terminate action"
+
 // startKind is the Kind of the node a body's entry transitions leave, which a
 // state diagram draws as its start marker.
 const startKind = "start"
@@ -235,8 +240,8 @@ func bodyOwning(graph *lower.StateGraph, state *ast.StateNode) ast.Node {
 }
 
 // transitionLabel is a transition edge's trigger, guard and effect, `after 5 [ok] /
-// effect`; a transition with none of those is labelled by its name.
-func (r *Renderer) transitionLabel(doc string, transition *lower.Transition) string {
+// effect`; a transition with none of those is labelled by its name, unless synthesized.
+func (r *Renderer) transitionLabel(doc string, transition *lower.Transition, synthesized bool) string {
 	var parts []string
 	if trigger := r.triggerLabel(doc, transition.Trigger); trigger != "" {
 		parts = append(parts, trigger)
@@ -250,13 +255,14 @@ func (r *Renderer) transitionLabel(doc string, transition *lower.Transition) str
 	if len(transition.Effect) > 0 {
 		parts = append(parts, "/ "+behaviorNames(transition.Effect))
 	}
-	return edgeLabel(transition.Name, strings.Join(parts, " "))
+	return edgeLabel(transition.Name, strings.Join(parts, " "), synthesized)
 }
 
 // edgeLabel is text when the edge has any of its own, else its name: a name
-// only labels an edge that nothing else describes.
-func edgeLabel(name, text string) string {
-	if text != "" || name == "" {
+// only labels an edge that nothing else describes, and a name a migration made
+// up (synthesized) labels nothing, as the unnamed source edge it stands for.
+func edgeLabel(name, text string, synthesized bool) string {
+	if text != "" || name == "" || synthesized {
 		return text
 	}
 	return nameText(name)
@@ -411,14 +417,14 @@ func (r *Renderer) actionNode(subject actionSubject, ids *nodeIDs, out *Renderin
 		out.Notices = append(out.Notices, fmt.Sprintf("%s %s does not lower to an action graph: %v", kind, name, err))
 		return nil, false
 	}
-	root := &Node{ID: ids.take(), Kind: kind, Name: name, Type: subject.typ, Origin: nodeOrigin(doc, decl),
-		Inherited: inheritedOrigins(graph.Inherited()), Geometry: r.declaredGeometryOf(subject.view, subject.elem, decl, out)}
+	root := &Node{ID: ids.take(), Kind: kind, Name: name, NameSynthesized: r.declaredNameSynthesized(subject.elem, decl), Type: subject.typ,
+		Origin: nodeOrigin(doc, decl), Inherited: inheritedOrigins(graph.Inherited()), Geometry: r.declaredGeometryOf(subject.view, subject.elem, decl, out)}
 	lowered[decl] = true
 	nodes := map[ast.Node]*Node{}
 	for _, node := range graph.Nodes {
 		nodeDoc := docOf(graph, node, doc)
 		child := &Node{ID: ids.take(), Kind: actionNodeKind(node, graph), Name: nameText(behaviorNodeName(node)),
-			Type: nodeType(node), Origin: nodeOrigin(nodeDoc, node),
+			NameSynthesized: languageNamed(node) || r.declaredNameSynthesized(subject.elem, node), Type: nodeType(node), Origin: nodeOrigin(nodeDoc, node),
 			Geometry: r.declaredGeometryOf(subject.view, subject.elem, node, out)}
 		nodes[node] = child
 		root.Children = append(root.Children, child)
@@ -457,8 +463,9 @@ func (r *Renderer) actionEdges(subject actionSubject, graph *lower.ActionGraph,
 				continue
 			}
 			edgeDoc := docOf(graph, edge.Decl, doc)
-			out.Edges = append(out.Edges, Edge{From: nodes[src].ID, To: to.ID, Label: r.successionLabel(edge, edgeDoc, doc), Kind: EdgeSuccession,
-				Origin: nodeOrigin(edgeDoc, edge.Decl), Route: r.declaredRouteOf(subject.view, subject.elem, edge.Decl, out)})
+			label := r.successionLabel(edge, edgeDoc, doc, r.declaredNameSynthesized(subject.elem, edge.Decl))
+			out.Edges = append(out.Edges, Edge{From: nodes[src].ID, To: to.ID, Label: label,
+				Kind: EdgeSuccession, Origin: nodeOrigin(edgeDoc, edge.Decl), Route: r.declaredRouteOf(subject.view, subject.elem, edge.Decl, out)})
 		}
 		for _, flow := range graph.DataFlows[src] {
 			to, ok := nodes[flow.Target]
@@ -467,15 +474,16 @@ func (r *Renderer) actionEdges(subject actionSubject, graph *lower.ActionGraph,
 					nameText(behaviorNodeName(src)), name))
 				continue
 			}
-			out.Edges = append(out.Edges, Edge{From: nodes[src].ID, To: to.ID, Label: flowLabel(flow), Kind: EdgeFlow,
-				Origin: nodeOrigin(docOf(graph, flow.Decl, doc), flow.Decl), Route: r.declaredRouteOf(subject.view, subject.elem, flow.Decl, out)})
+			label := flowLabel(flow, r.declaredNameSynthesized(subject.elem, flow.Decl))
+			out.Edges = append(out.Edges, Edge{From: nodes[src].ID, To: to.ID, Label: label,
+				Kind: EdgeFlow, Origin: nodeOrigin(docOf(graph, flow.Decl, doc), flow.Decl), Route: r.declaredRouteOf(subject.view, subject.elem, flow.Decl, out)})
 		}
 	}
 }
 
 // successionLabel is the succession's guard in brackets, then its probability;
-// a succession with neither is labelled by its name.
-func (r *Renderer) successionLabel(edge lower.ActionEdge, edgeDoc, doc string) string {
+// a succession with neither is labelled by its name, unless synthesized.
+func (r *Renderer) successionLabel(edge lower.ActionEdge, edgeDoc, doc string, synthesized bool) string {
 	label := ""
 	if guard := edge.Guard; guard != nil {
 		if text := r.nodeText(edgeDoc, guard); text != "" {
@@ -487,17 +495,17 @@ func (r *Renderer) successionLabel(edge lower.ActionEdge, edgeDoc, doc string) s
 	if weight := edge.Probability; weight != nil {
 		label = strings.TrimSpace(label + " p = " + r.nodeText(doc, weight.Expr))
 	}
-	return edgeLabel(edge.Name, label)
+	return edgeLabel(edge.Name, label, synthesized)
 }
 
 // flowLabel is what an object flow carries: the pins it joins; a flow naming no
-// pins is labelled by its name.
-func flowLabel(flow lower.ObjectFlow) string {
+// pins is labelled by its name, unless synthesized.
+func flowLabel(flow lower.ObjectFlow, synthesized bool) string {
 	label := flow.SourcePin
 	if flow.TargetPin != "" {
 		label = strings.TrimPrefix(label+" to "+flow.TargetPin, " to ")
 	}
-	return edgeLabel(flow.Name, label)
+	return edgeLabel(flow.Name, label, synthesized)
 }
 
 // nestedAction is the declaration of an action node that performs a body of its
@@ -552,6 +560,9 @@ func actionNodeKind(node ast.Node, graph *lower.ActionGraph) string {
 	case *ast.StateNode:
 		return "state"
 	case *ast.Usage:
+		if lower.IsTerminateUsage(n) {
+			return terminateKind
+		}
 		return n.Kind.String()
 	case *ast.Definition:
 		return n.Kind.String() + " def"
@@ -559,6 +570,16 @@ func actionNodeKind(node ast.Node, graph *lower.ActionGraph) string {
 	return "node"
 }
 
+// languageNamed reports whether a graph node's name is the language's, not the
+// body's: the `start` an action's flow leaves and the `done` it ends at.
+func languageNamed(node ast.Node) bool {
+	switch node.(type) {
+	case *ast.InitialNode, *ast.FinalNode:
+		return true
+	}
+	return false
+}
+
 // behaviorNodeName is the name a state or action graph node was declared with.
 func behaviorNodeName(node ast.Node) string {
 	switch n := node.(type) {
diff --git a/internal/ir/view/bookkeeping_test.go b/internal/ir/view/bookkeeping_test.go
new file mode 100644
index 000000000..dbae3cb5e
--- /dev/null
+++ b/internal/ir/view/bookkeeping_test.go
@@ -0,0 +1,134 @@
+package view
+
+import (
+	"maps"
+	"slices"
+	"strings"
+	"testing"
+)
+
+// allNodes walks a rendering's nodes in depth-first order.
+func allNodes(roots []*Node) []*Node {
+	var out []*Node
+	for _, node := range roots {
+		out = append(out, node)
+		out = append(out, allNodes(node.Children)...)
+	}
+	return out
+}
+
+// A tree shows the model, not the picture of it: a view's `render` member and
+// every DiagramLayout annotation are left out, whether stated inline on the
+// element, about a member, or in a view's body. Ordinary metadata stays.
+func TestTreeLeavesOutLayoutAndRenderMembers(t *testing.T) {
+	rendering := render(t, "bookkeeping.sysml", "BudgetViews::budgetView")
+	names := nodeNames(rendering.Roots)
+	for _, want := range []string{"Mirror", "errorReq", "errorCBE", "Approved", "details", "asTree"} {
+		if !names[want] {
+			t.Errorf("node %q missing; nodes: %v", want, slices.Sorted(maps.Keys(names)))
+		}
+	}
+	for _, node := range allNodes(rendering.Roots) {
+		switch {
+		case node.Kind == "metadata" && node.Type != "Approved":
+			t.Errorf("layout annotation drawn as node %q : %q", node.Name, node.Type)
+		case node.Kind == "render" || node.Name == "asTreeDiagram":
+			t.Errorf("render member drawn as node %q", node.Name)
+		}
+	}
+	for _, name := range []string{"x", "y", "width", "height", "unit", "placed"} {
+		if names[name] {
+			t.Errorf("layout bookkeeping %q drawn as a node", name)
+		}
+	}
+	details := findNode(t, rendering.Roots, "details")
+	if len(details.Children) != 0 {
+		t.Errorf("view details has children %v, want none", nodeNames(details.Children))
+	}
+}
+
+// What a tree does not draw, no Layout can position.
+func TestLayoutAnnotationsAreNotDrawn(t *testing.T) {
+	r, idx := loadFixtures(t, "bookkeeping.sysml")
+	for _, fqn := range []string{"Budget::Mirror::placed", "Budget::Mirror::details::asTreeDiagram"} {
+		syms := idx.LookupQualified(fqn)
+		if len(syms) == 0 {
+			continue
+		}
+		if node, _ := r.draws(KindTree, syms[0]); node {
+			t.Errorf("%s is drawn by a tree rendering", fqn)
+		}
+	}
+	if node, _ := r.draws(KindTree, lookup(t, idx, "Budget::asTree")); !node {
+		t.Error("Budget::asTree is a rendering usage outside a view; a tree draws it")
+	}
+}
+
+// A name the migration made up (MigrationMetadata::SynthesizedName) keys its
+// node but is not one a picture shows: the node carries the bit, as does the
+// language's own start of an action's flow, and an edge with no text but such
+// a name carries no label, in every rendering kind. The marker itself, being
+// about the migration and not the model, is drawn by none.
+func TestSynthesizedNamesAreReadFromTheModel(t *testing.T) {
+	synthesized := map[string]bool{"start": true, "'fork'": true, "final": true, "wheel": true, "'start to call'": true, "'call to fork'": true,
+		"'fork to log'": true, "'fork to final'": true, "'Idle accept Go then Running'": true, "'engine to wheel'": true}
+	authored := []string{"call", "log", "Idle", "Running", "engine", "Track", "Modes", "Vehicle"}
+	for _, view := range []string{"MigratedViews::trackView", "MigratedViews::modesView", "MigratedViews::vehicleView", "MigratedViews::treeView"} {
+		rendering := render(t, "synthesized.sysml", view)
+		for _, node := range allNodes(rendering.Roots) {
+			if node.NameSynthesized != synthesized[node.Name] {
+				t.Errorf("%s: node %q NameSynthesized = %v, want %v", view, node.Name, node.NameSynthesized, synthesized[node.Name])
+			}
+			if node.Kind == "metadata" {
+				t.Errorf("%s: synthesized-name marker drawn as node %q : %q", view, node.Name, node.Type)
+			}
+		}
+		names := nodeNames(rendering.Roots)
+		for _, name := range authored {
+			if !names[name] && view != "MigratedViews::treeView" {
+				continue
+			}
+			if !names[name] {
+				t.Errorf("%s: node %q missing; nodes: %v", view, name, slices.Sorted(maps.Keys(names)))
+			}
+		}
+	}
+
+	track := render(t, "synthesized.sysml", "MigratedViews::trackView")
+	labels := edgeLabels(track)
+	for _, label := range []string{"'start to call'", "'call to fork'", "'fork to log'", "'fork to final'", "start to call", "fork to log"} {
+		if labels[label] {
+			t.Errorf("succession's synthesized name %q labels an edge", label)
+		}
+	}
+	if !labels["finish"] {
+		t.Errorf("authored succession name finish labels no edge; labels: %v", slices.Sorted(maps.Keys(labels)))
+	}
+
+	modes := render(t, "synthesized.sysml", "MigratedViews::modesView")
+	labels = edgeLabels(modes)
+	for _, want := range []string{"accept Go", "accept Stop"} {
+		if !labels[want] {
+			t.Errorf("transition trigger %q labels no edge; labels: %v", want, slices.Sorted(maps.Keys(labels)))
+		}
+	}
+	if labels["'Idle accept Go then Running'"] {
+		t.Error("transition's synthesized name labels an edge over its trigger")
+	}
+
+	vehicle := render(t, "synthesized.sysml", "MigratedViews::vehicleView")
+	labels = edgeLabels(vehicle)
+	if labels["'engine to wheel'"] || labels["engine to wheel"] {
+		t.Errorf("connection's synthesized name labels an edge; labels: %v", slices.Sorted(maps.Keys(labels)))
+	}
+	if !labels["drive"] || !labels["connection"] {
+		t.Errorf("connection labels = %v, want the authored name drive and the keyword for the synthesized one", slices.Sorted(maps.Keys(labels)))
+	}
+	dot, err := vehicle.DOT()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(dot, "label=<<b>: Wheel</b>") || strings.Contains(dot, ">wheel") {
+		t.Errorf("part with a synthesized name is not drawn as `: Wheel` alone:\n%s", dot)
+	}
+}
diff --git a/internal/ir/view/data.go b/internal/ir/view/data.go
index 9e3dbcba0..97476c4be 100644
--- a/internal/ir/view/data.go
+++ b/internal/ir/view/data.go
@@ -27,11 +27,13 @@ type Data struct {
 
 // NodeData is one node of a rendering, with the node it is nested in.
 type NodeData struct {
-	ID     string
-	Kind   string
-	Name   string
-	Type   string
-	Detail string
+	ID   string
+	Kind string
+	Name string
+	// NameSynthesized marks a Name the model did not give: a name to key by, not one a picture shows.
+	NameSynthesized bool
+	Type            string
+	Detail          string
 	// Parent is the ID of the node this one is nested in, "" for a root.
 	Parent string
 	Origin Origin
@@ -89,8 +91,8 @@ func appendNodeData(out []NodeData, node *Node, parent string) []NodeData {
 		return out
 	}
 	out = append(out, NodeData{
-		ID: node.ID, Kind: node.Kind, Name: node.Name, Type: node.Type, Detail: node.Detail, Parent: parent, Origin: node.Origin,
-		Geometry: node.Geometry,
+		ID: node.ID, Kind: node.Kind, Name: node.Name, NameSynthesized: node.NameSynthesized, Type: node.Type, Detail: node.Detail,
+		Parent: parent, Origin: node.Origin, Geometry: node.Geometry,
 	})
 	for _, child := range node.Children {
 		out = appendNodeData(out, child, node.ID)
diff --git a/internal/ir/view/dot.go b/internal/ir/view/dot.go
index 2f87927f2..985a60ccb 100644
--- a/internal/ir/view/dot.go
+++ b/internal/ir/view/dot.go
@@ -27,7 +27,8 @@ import (
 //
 // DiagramLayout geometry is written as Graphviz reads it (pinned `pos`, `bb`,
 // `pos` splines, pinned canvas corners); docs/project/view-rendering-forms.md#geometry
-// has the rules.
+// has the rules. A drawing some Layout positions leaves the nodes none does
+// undrawn, or sets them in a strip below it when asked (Options.Unplaced).
 //
 // The drawing is in the Standard B&W style of the SysML v2 Pilot visualizer
 // (docs/project/view-rendering-forms.md#style): Helvetica, white fills, thin
@@ -42,9 +43,10 @@ func (r *Rendering) DOT() (string, error) {
 
 // DOTWith is the DOT form written with options: laid out in the stated
 // direction, as `rankdir` (the empty direction leaves the engine's default and
-// writes no `rankdir`), and filled from the stated palette by keyword family
-// (the empty palette draws in black and white). The layout is the same
-// whatever the palette: it changes fills and borders alone.
+// writes no `rankdir`), filled from the stated palette by keyword family (the
+// empty palette draws in black and white), and with the nodes a positioned
+// drawing leaves unplaced undrawn or set in a strip below it. The layout is
+// the same whatever the palette: it changes fills and borders alone.
 func (r *Rendering) DOTWith(options Options) (string, error) {
 	if !r.Kind.SupportsForm(FormDot) {
 		return "", &WrongFormError{Form: FormDot, Kind: r.Kind, View: r.View}
@@ -52,18 +54,16 @@ func (r *Rendering) DOTWith(options Options) (string, error) {
 	if err := options.Palette.check(); err != nil {
 		return "", err
 	}
+	if err := options.Unplaced.check(); err != nil {
+		return "", err
+	}
 	direction := options.Direction
-	w := &dotWriter{tree: r.Kind == KindTree, clusters: map[string]bool{}, enclosing: map[string][]string{}, canvas: r.Canvas,
-		boxes: map[string]nodeBox{}, fills: familyFills{palette: options.Palette, tree: r.Kind == KindTree}, labels: labelsOf(r.Roots)}
-	w.placeNodes(r.Roots, r.Edges)
-	for _, root := range r.Roots {
-		if !w.tree {
-			w.collectClusters(root, nil)
-		}
-		w.countPlaced(root)
-		w.fills.collect(root)
+	w := newDOTWriter(r, options)
+	edges := r.Edges
+	if w.placed > 0 && w.placed < w.nodes {
+		edges = w.settleUnplaced(r.Roots, r.Edges, options.Unplaced)
 	}
-	for _, edge := range r.Edges {
+	for _, edge := range edges {
 		if w.clipped(edge.From, edge.To) || w.clipped(edge.To, edge.From) {
 			w.compound = true
 		}
@@ -75,9 +75,6 @@ func (r *Rendering) DOTWith(options Options) (string, error) {
 			w.notices = append(w.notices, fmt.Sprintf("route of %s->%s is one waypoint, (%s, %s); a line needs two", edge.From, edge.To, formatCoord(p.X), formatCoord(p.Y)))
 		}
 	}
-	if engine := w.engine(); w.routed > 0 && engine != "neato -n2" {
-		w.notices = append(w.notices, fmt.Sprintf("%d route(s) written as pos; %s redraws every edge, only neato -n2 keeps them", w.routed, engine))
-	}
 	b := &w.b
 	if r.View != "" {
 		fmt.Fprintf(b, "// view: %s\n", r.View)
@@ -114,16 +111,163 @@ func (r *Rendering) DOTWith(options Options) (string, error) {
 		b.WriteString("}\n")
 		return b.String(), nil
 	}
-	for _, root := range r.Roots {
+	for _, root := range w.drawOrder(r.Roots) {
 		w.writeNode(root, 1)
 	}
-	for _, edge := range r.Edges {
+	for _, edge := range edges {
 		w.writeEdge(edge.From, edge.To, w.dotEdgeAttributes(edge))
 	}
 	b.WriteString("}\n")
 	return b.String(), nil
 }
 
+// newDOTWriter is the writer for r with every node that has a box placed in
+// it, the clusters and the palette's families collected.
+func newDOTWriter(r *Rendering, options Options) *dotWriter {
+	w := &dotWriter{tree: r.Kind == KindTree, clusters: map[string]bool{}, enclosing: map[string][]string{}, canvas: r.Canvas,
+		boxes: map[string]nodeBox{}, omitted: map[string]bool{}, fills: familyFills{palette: options.Palette, tree: r.Kind == KindTree}, labels: labelsOf(r.Roots)}
+	w.placeNodes(r.Roots, r.Edges)
+	for _, root := range r.Roots {
+		if !w.tree {
+			w.collectClusters(root, nil)
+		}
+		w.countPlaced(root)
+		w.fills.collect(root)
+	}
+	return w
+}
+
+// settleUnplaced settles the nodes a positioned drawing leaves unplaced, as
+// asked: boxed in a strip below the drawing, or left undrawn with the edges
+// at them; either is noticed. The edges left to write are returned.
+func (w *dotWriter) settleUnplaced(roots []*Node, edges []Edge, unplaced Unplaced) []Edge {
+	count := w.nodes - w.placed
+	if unplaced == UnplacedStrip {
+		w.stripUnplaced(roots, edges)
+		w.placed = w.nodes
+		w.notices = append(w.notices, fmt.Sprintf("%d node(s) without a position, drawn in a strip below the drawing", count))
+		return edges
+	}
+	w.omitUnplaced(roots)
+	kept := make([]Edge, 0, len(edges))
+	for _, edge := range edges {
+		if !w.omitted[edge.From] && !w.omitted[edge.To] {
+			kept = append(kept, edge)
+		}
+	}
+	notice := fmt.Sprintf("%d node(s) without a position, left undrawn", count)
+	if dropped := len(edges) - len(kept); dropped > 0 {
+		notice += fmt.Sprintf(", and %d edge(s) at them", dropped)
+	}
+	w.notices = append(w.notices, notice)
+	return kept
+}
+
+// omitUnplaced marks every node under nodes that has no box as undrawn.
+func (w *dotWriter) omitUnplaced(nodes []*Node) {
+	for _, node := range nodes {
+		if _, ok := w.boxes[node.ID]; !ok {
+			w.omitted[node.ID] = true
+		}
+		w.omitUnplaced(node.Children)
+	}
+}
+
+// dotStripGap is the space, in pixels, between the drawing and the strip of
+// unplaced nodes below it, and between the boxes in the strip.
+const dotStripGap = 24
+
+// stripUnplaced boxes the unplaced nodes in rows in a strip below everything
+// the drawing places — the canvas, every box, every route — as wide as that.
+func (w *dotWriter) stripUnplaced(roots []*Node, edges []Edge) {
+	w.stated = make(map[string]bool, len(w.boxes))
+	for id := range w.boxes {
+		w.stated[id] = true
+	}
+	extent := w.extent(edges)
+	corner := Point{X: extent.low.X, Y: extent.high.Y + dotStripGap}
+	w.packRows(w.unplacedTops(roots), corner, extent.high.X-extent.low.X)
+}
+
+// extent is the box round everything placed: the sized canvas, every box and
+// every route's waypoints.
+func (w *dotWriter) extent(edges []Edge) nodeBox {
+	var extent *nodeBox
+	add := func(box nodeBox) {
+		if extent == nil {
+			extent = &box
+			return
+		}
+		*extent = extent.union(box)
+	}
+	if c := w.canvas; c != nil && c.HasSize {
+		add(nodeBox{high: Point{X: c.Width, Y: c.Height}})
+	}
+	for _, box := range w.boxes {
+		add(box)
+	}
+	for _, edge := range edges {
+		for _, p := range edge.Route {
+			add(nodeBox{low: p, high: p})
+		}
+	}
+	return *extent
+}
+
+// unplacedTops are the unplaced nodes the strip packs as items, in walk order:
+// an unplaced cluster packs its own members, a tree's nodes are each an item.
+func (w *dotWriter) unplacedTops(nodes []*Node) []*Node {
+	var tops []*Node
+	for _, node := range nodes {
+		if !w.stated[node.ID] {
+			tops = append(tops, node)
+			if !w.tree {
+				continue
+			}
+		}
+		tops = append(tops, w.unplacedTops(node.Children)...)
+	}
+	return tops
+}
+
+// packRows boxes nodes in rows from corner, a gap apart, wrapping before a box
+// would overrun across (a box wider than that has a row to itself); the box
+// round them all. Corners fall on whole pixels.
+func (w *dotWriter) packRows(nodes []*Node, corner Point, across float64) nodeBox {
+	corner = Point{X: math.Ceil(corner.X), Y: math.Ceil(corner.Y)}
+	packed := nodeBox{low: corner, high: corner}
+	at, rowHeight := corner, 0.0
+	for _, node := range nodes {
+		box := w.stripBox(node, at, across)
+		if box.high.X > corner.X+across && at.X > corner.X {
+			at, rowHeight = Point{X: corner.X, Y: math.Ceil(at.Y + rowHeight + dotStripGap)}, 0
+			box = w.stripBox(node, at, across)
+		}
+		packed = packed.union(box)
+		rowHeight = math.Max(rowHeight, box.high.Y-box.low.Y)
+		at.X = math.Ceil(box.high.X + dotStripGap)
+	}
+	return packed
+}
+
+// stripBox boxes an unplaced node with its top-left corner at corner: a plain
+// node in its label's box, a cluster round its title and its members packed in
+// rows below it, a margin about them.
+func (w *dotWriter) stripBox(node *Node, corner Point, across float64) nodeBox {
+	if len(node.Children) == 0 || w.tree {
+		width, height := w.labels.dotBox(node)
+		box := nodeBox{low: corner, high: Point{X: corner.X + width, Y: corner.Y + height}}
+		w.boxes[node.ID] = box
+		return box
+	}
+	_, title := w.labels.dotLabelExtent(node)
+	inner := Point{X: corner.X + dotClusterMargin, Y: corner.Y + title + dotClusterMargin}
+	members := w.packRows(w.unplacedTops(node.Children), inner, math.Max(across-2*dotClusterMargin, 1))
+	box := nodeBox{low: corner, high: Point{X: members.high.X + dotClusterMargin, Y: members.high.Y + dotClusterMargin}}
+	w.boxes[node.ID] = box
+	return box
+}
+
 // dotWriter holds what one rendering's DOT form needs across nodes and edges.
 type dotWriter struct {
 	b         strings.Builder
@@ -133,7 +277,9 @@ type dotWriter struct {
 	compound  bool                // an edge is clipped at a cluster
 	canvas    *Canvas             // the surface positions are flipped against
 	boxes     map[string]nodeBox  // node ID -> the box it is drawn in, for every node that has one
-	nodes     int                 // nodes written, and how many are positioned
+	stated    map[string]bool     // node IDs the drawing itself boxes, once a strip adds boxes of its own
+	omitted   map[string]bool     // node IDs left undrawn for want of a box
+	nodes     int                 // nodes in the rendering, and how many have a box
 	placed    int
 	routed    int         // edges with a route to write
 	notices   []string    // geometry the form cannot draw
@@ -173,9 +319,11 @@ func (w *dotWriter) countPlaced(node *Node) {
 	}
 }
 
-// nodeBox is where a node is drawn: its box in pixels, top-left to bottom-right.
+// nodeBox is where a node is drawn, top-left to bottom-right in pixels; stated
+// when the Layout gives its size and not only its corner.
 type nodeBox struct {
 	low, high Point
+	stated    bool
 }
 
 // centre is the middle of the box, the point Graphviz pins a node at.
@@ -183,6 +331,12 @@ func (b nodeBox) centre() Point {
 	return Point{X: (b.low.X + b.high.X) / 2, Y: (b.low.Y + b.high.Y) / 2}
 }
 
+// encloses reports whether other lies within b and is the smaller of the two.
+func (b nodeBox) encloses(other nodeBox) bool {
+	return other != b && other.low.X >= b.low.X && other.low.Y >= b.low.Y &&
+		other.high.X <= b.high.X && other.high.Y <= b.high.Y
+}
+
 // routeEnd is where a route meets a node, and the waypoint it goes on to.
 type routeEnd struct {
 	at, next Point
@@ -228,7 +382,7 @@ func (w *dotWriter) placeNode(node *Node, ends map[string][]routeEnd) {
 func (w *dotWriter) statedBox(node *Node) nodeBox {
 	g := node.Geometry
 	width, height := w.labels.dotBox(node)
-	return nodeBox{low: Point{X: g.X, Y: g.Y}, high: Point{X: g.X + width, Y: g.Y + height}}
+	return nodeBox{low: Point{X: g.X, Y: g.Y}, high: Point{X: g.X + width, Y: g.Y + height}, stated: g.HasSize}
 }
 
 // routedBox is the box a node with no Layout takes from the routes that meet
@@ -255,7 +409,7 @@ func (w *dotWriter) routedBox(node *Node, ends []routeEnd) nodeBox {
 // dotReach is the distance from the centre of a node's shape to its border along
 // a unit direction: a round pseudo-state's radius, the edge of a box otherwise.
 func dotReach(node *Node, width, height, ux, uy float64) float64 {
-	if node.Kind == startKind || node.Kind == "initial" || node.Kind == "final" {
+	if dotRound(node) {
 		return width / 2
 	}
 	reach := math.Inf(1)
@@ -270,12 +424,11 @@ func dotReach(node *Node, width, height, ux, uy float64) float64 {
 
 // engine is the Graphviz command the text is written for: `neato -n` keeps every
 // node where it is pinned, `-n2` keeps the routes too and draws the other edges.
+// Every node drawn in a positioned drawing is pinned, so plain `neato` is never named.
 func (w *dotWriter) engine() string {
 	switch {
 	case w.placed == 0:
 		return "dot"
-	case w.placed < w.nodes:
-		return "neato"
 	case w.routed > 0:
 		return "neato -n2"
 	}
@@ -356,15 +509,44 @@ func dotInches(px float64) string {
 	return formatCoord(px / 72)
 }
 
+// drawOrder moves a placed sibling ahead of the siblings its box encloses, which
+// Graphviz would otherwise paint it over, as it paints in file order.
+func (w *dotWriter) drawOrder(nodes []*Node) []*Node {
+	ordered := make([]*Node, 0, len(nodes))
+	for _, node := range nodes {
+		at := len(ordered)
+		if box, ok := w.boxes[node.ID]; ok {
+			at = slices.IndexFunc(ordered, func(other *Node) bool {
+				inner, ok := w.boxes[other.ID]
+				return ok && box.encloses(inner)
+			})
+			if at < 0 {
+				at = len(ordered)
+			}
+		}
+		ordered = slices.Insert(ordered, at, node)
+	}
+	return ordered
+}
+
 // writeNode writes one node: a cluster holding its children, a plain node
-// otherwise. A tree writes the node and an edge to each child instead.
+// otherwise. A tree writes the node and an edge to each child instead. An
+// omitted node writes nothing but the nodes under it, in its place.
 func (w *dotWriter) writeNode(node *Node, depth int) {
 	indent := strings.Repeat("  ", depth)
+	if w.omitted[node.ID] {
+		for _, child := range w.drawOrder(node.Children) {
+			w.writeNode(child, depth)
+		}
+		return
+	}
 	if len(node.Children) == 0 || w.tree {
 		fmt.Fprintf(&w.b, "%s%s [%s];\n", indent, dotQuote(node.ID), strings.Join(w.dotNodeAttributes(node), ", "))
-		for _, child := range node.Children {
+		for _, child := range w.drawOrder(node.Children) {
 			w.writeNode(child, depth)
-			w.writeEdge(node.ID, child.ID, dotContainmentAttributes())
+			if !w.omitted[child.ID] {
+				w.writeEdge(node.ID, child.ID, dotContainmentAttributes())
+			}
 		}
 		return
 	}
@@ -373,7 +555,7 @@ func (w *dotWriter) writeNode(node *Node, depth int) {
 		fmt.Fprintf(&w.b, "%s  %s;\n", indent, attr)
 	}
 	fmt.Fprintf(&w.b, "%s  %s [%s];\n", indent, dotQuote(node.ID), strings.Join(w.dotAnchorAttributes(node), ", "))
-	for _, child := range node.Children {
+	for _, child := range w.drawOrder(node.Children) {
 		w.writeNode(child, depth+1)
 	}
 	fmt.Fprintf(&w.b, "%s}\n", indent)
@@ -400,10 +582,13 @@ func (w *dotWriter) writeEdge(from, to string, attrs []string) {
 // position and size when a box places it.
 func (w *dotWriter) dotNodeAttributes(node *Node) []string {
 	var attrs []string
-	switch node.Kind {
-	case startKind:
+	stated := node.Geometry != nil && node.Geometry.HasSize
+	switch {
+	case node.Kind == startKind:
 		attrs = []string{"shape=point", "fillcolor=black", `label=""`}
-	case "initial", "final":
+	case stated && isSymbolKind(node.Kind):
+		attrs = w.dotSymbolAttributes(node)
+	case node.Kind == "initial" || node.Kind == "final":
 		attrs = w.dotPseudostateAttributes(node)
 	default:
 		if !controlKinds[node.Kind] && !isDefinitionKind(node.Kind) {
@@ -412,7 +597,11 @@ func (w *dotWriter) dotNodeAttributes(node *Node) []string {
 		if w.fills.filled(node) {
 			attrs = append(attrs, "fillcolor="+dotQuote(w.fills.fill(node)), dotColorAttr(w.fills.color(node)), "penwidth=1")
 		}
-		attrs = append(attrs, w.labels.dotLabel(node))
+		if stated {
+			attrs = append(attrs, w.dotStatedLabel(node)...)
+		} else {
+			attrs = append(attrs, w.labels.dotLabel(node))
+		}
 	}
 	if box, ok := w.boxes[node.ID]; ok {
 		width, height := w.labels.dotBox(node)
@@ -420,7 +609,7 @@ func (w *dotWriter) dotNodeAttributes(node *Node) []string {
 		if node.Kind != startKind {
 			attrs = append(attrs, "width="+dotInches(width), "height="+dotInches(height))
 		}
-		if g := node.Geometry; g != nil && g.HasSize {
+		if stated {
 			attrs = append(attrs, "fixedsize=true")
 		}
 		if g := node.Geometry; g != nil && g.Collapsed {
@@ -430,19 +619,114 @@ func (w *dotWriter) dotNodeAttributes(node *Node) []string {
 	return attrs
 }
 
+// dotStatedLabel is a stated box's label attributes: the label fitted to the
+// box's width and its headroom with no margin taken off them, set at the top
+// when that is a header strip; when the room holds no line even at the floor,
+// the head is set outside as `xlabel`.
+func (w *dotWriter) dotStatedLabel(node *Node) []string {
+	width := node.Geometry.Width
+	height, header := w.headroom(node)
+	if !dotHoldsALine(width, height) {
+		attrs := []string{`label=""`}
+		if keyworded(node) {
+			attrs = append(attrs, "xlabel="+dotQuote(w.labels.head(node)))
+		}
+		return attrs
+	}
+	attrs := []string{w.labels.dotFittedLabel(node, width, height), "margin=0"}
+	if header {
+		attrs = append(attrs, "labelloc=t")
+	}
+	return attrs
+}
+
+// dotHoldsALine reports whether a box has room for one line of one glyph at the floor size.
+func dotHoldsALine(width, height float64) bool {
+	return width >= dotFitFloor*dotBoldGlyphEm && height >= dotFitFloor*dotLineEm
+}
+
+// headroom is the height a stated box has for its title: the strip above the
+// topmost stated box it encloses (header), or the whole box when it encloses none.
+func (w *dotWriter) headroom(node *Node) (height float64, header bool) {
+	box := w.boxes[node.ID]
+	top := box.high.Y
+	for _, inner := range w.boxes {
+		if inner.stated && box.encloses(inner) && inner.low.Y < top {
+			top, header = inner.low.Y, true
+		}
+	}
+	return top - box.low.Y, header
+}
+
+// isSymbolKind reports whether a kind has a notation symbol a stated box is drawn
+// as, with no text inside it: the control and pseudo-state nodes and a port.
+func isSymbolKind(kind string) bool {
+	switch kind {
+	case "initial", "final", terminateKind, "fork", "join", "merge", "decision", "choice", "junction":
+		return true
+	}
+	return isPortKind(kind)
+}
+
+// dotRound reports whether a node is drawn round, so an edge reaches its border
+// at its radius: the start point, the pseudo-states, and a stated junction or
+// terminate action.
+func dotRound(node *Node) bool {
+	switch node.Kind {
+	case startKind, "initial", "final":
+		return true
+	case "junction", terminateKind:
+		return node.Geometry != nil && node.Geometry.HasSize
+	}
+	return false
+}
+
+// isPortKind reports whether a kind is a port usage: `port`, `ref port`, but no
+// `port def`.
+func isPortKind(kind string) bool {
+	return slices.Contains(strings.Fields(kind), "port") && !isDefinitionKind(kind)
+}
+
+// dotSymbolAttributes draws a symbol kind in its stated box as the notation's symbol: a
+// diamond, a filled bar or a port's square (the default box at the stated size), the
+// filled dot or double ring. A given name or a type is set outside as `xlabel`;
+// a synthesized name is not drawn.
+func (w *dotWriter) dotSymbolAttributes(node *Node) []string {
+	var attrs []string
+	switch node.Kind {
+	case "decision", "merge", "choice":
+		attrs = []string{"shape=diamond"}
+	case "fork", "join":
+		attrs = []string{"fillcolor=black"}
+	case "initial", "junction":
+		attrs = []string{"shape=circle", "fillcolor=black"}
+	case "final", terminateKind:
+		attrs = []string{"shape=doublecircle", "fillcolor=black"}
+	default:
+		if w.fills.filled(node) {
+			attrs = append(attrs, "fillcolor="+dotQuote(w.fills.fill(node)), dotColorAttr(w.fills.color(node)), "penwidth=1")
+		}
+	}
+	attrs = append(attrs, `label=""`)
+	if keyworded(node) {
+		attrs = append(attrs, "xlabel="+dotQuote(w.labels.head(node)))
+	}
+	return attrs
+}
+
 // dotPseudostateSize is the diameter, in points, of an initial or final
 // pseudo-state drawn as the UML filled dot, with no name to show: 0.2in.
 const dotPseudostateSize = 14.4
 
 // dotPseudostateAttributes is an initial or final node's shape and label: the
-// UML filled black dot, or double ring, when it has no name to show, a labelled
-// circle when the rendering names it. A placed one keeps its placed size.
+// UML filled black dot, or double ring, when it has no given name to show, a
+// labelled circle when the rendering names it. A placed one keeps its placed size.
 func (w *dotWriter) dotPseudostateAttributes(node *Node) []string {
 	shape := "shape=circle"
 	if node.Kind == "final" {
 		shape = "shape=doublecircle"
 	}
-	if node.Name != "" {
+	if shown(node) != "" {
 		return []string{shape, w.labels.dotLabel(node)}
 	}
 	attrs := []string{shape, "fillcolor=black", `label=""`}
@@ -476,7 +760,7 @@ func (l labeller) dotBox(node *Node) (width, height float64) {
 	if node.Kind == startKind {
 		return dotPointSize, dotPointSize
 	}
-	if (node.Kind == "initial" || node.Kind == "final") && node.Name == "" {
+	if (node.Kind == "initial" || node.Kind == "final") && shown(node) == "" {
 		return dotPseudostateSize, dotPseudostateSize
 	}
 	width, height = l.dotLabelExtent(node)
@@ -497,7 +781,7 @@ func (l labeller) dotLabelExtent(node *Node) (width, height float64) {
 		switch {
 		case i == 0:
 			glyph = dotBoldGlyphEm
-		case i == 1 && node.Name != "":
+		case i == 1 && keyworded(node):
 			size = dotKeywordPointSize
 		}
 		width = math.Max(width, float64(utf8.RuneCountInString(line))*size*glyph)
@@ -506,6 +790,142 @@ func (l labeller) dotLabelExtent(node *Node) (width, height float64) {
 	return width, height
 }
 
+// dotFitFloor is the smallest font size, in points, a stated box's label shrinks to.
+const dotFitFloor = 8
+
+// dotFittedLabel is a node's label composed to fit a stated box: the head wrapped
+// at the box's width and shrunk from the default size to the largest at which it
+// fits, the keyword and detail lines after it while height remains. A head too
+// tall even at the floor is cut to the lines that fit and ellipsized.
+func (l labeller) dotFittedLabel(node *Node, width, height float64) string {
+	lines := l.lines(node)
+	size, head, fits := dotFitHead(lines[0], width, height)
+	parts := []string{dotSized(size, "<b>"+dotEscapeLines(head)+"</b>")}
+	left := height - float64(len(head))*size*dotLineEm
+	for i := 1; fits && i < len(lines); i++ {
+		keyword := i == 1 && keyworded(node)
+		lineSize := size
+		if keyword {
+			lineSize = math.Round(size * dotKeywordPointSize / dotFontSize)
+		}
+		wrapped := dotWrap(lines[i], dotRunesAcross(width, lineSize, dotGlyphEm))
+		used := float64(len(wrapped)) * lineSize * dotLineEm
+		if used > left {
+			break
+		}
+		left -= used
+		text := dotEscapeLines(wrapped)
+		if keyword {
+			text = "<i>" + text + "</i>"
+		}
+		parts = append(parts, dotSized(lineSize, text))
+	}
+	return dotLabelAttribute("<" + strings.Join(parts, "<br/>") + ">")
+}
+
+// dotFitHead wraps a head line into a box at the largest font size, from the
+// default down to the floor, at which it fits with its words whole, else at the
+// largest at which it fits with a word broken; when none does, the floor's
+// wrapping is cut to the lines the height holds, the last ellipsized.
+func dotFitHead(head string, width, height float64) (size float64, lines []string, fits bool) {
+	for _, whole := range []bool{true, false} {
+		for size = dotFontSize; size >= dotFitFloor; size-- {
+			across := dotRunesAcross(width, size, dotBoldGlyphEm)
+			if whole && dotBreaksAWord(head, across) {
+				continue
+			}
+			lines = dotWrap(head, across)
+			if float64(len(lines))*size*dotLineEm <= height {
+				return size, lines, true
+			}
+		}
+	}
+	size = dotFitFloor
+	across := dotRunesAcross(width, size, dotBoldGlyphEm)
+	lines = dotWrap(head, across)
+	down := max(1, int(height/(size*dotLineEm)))
+	if len(lines) > down {
+		lines = lines[:down]
+		last := []rune(lines[down-1])
+		lines[down-1] = string(last[:max(0, min(len(last), across-1))]) + "…"
+	}
+	return size, lines, false
+}
+
+// dotBreaksAWord reports whether wrapping text to across runes a line must break
+// a word: one longer than the line.
+func dotBreaksAWord(text string, across int) bool {
+	for _, word := range strings.Fields(text) {
+		if utf8.RuneCountInString(word) > across {
+			return true
+		}
+	}
+	return false
+}
+
+// dotRunesAcross is how many glyphs of a font size fit across a width, one at
+// least so a line can be written at all.
+func dotRunesAcross(width, size, glyph float64) int {
+	return max(1, int(width/(size*glyph)))
+}
+
+// dotWrap word-wraps text to at most across runes a line, breaking a word longer
+// than that at the rune it overruns. A ":" that would end a line instead leads
+// the type name after it onto the next, where the two fit together.
+func dotWrap(text string, across int) []string {
+	fits := func(line, word string) bool { // word fits on line, joined by a space when line is not empty
+		n := utf8.RuneCountInString(word)
+		if line != "" {
+			n += utf8.RuneCountInString(line) + 1
+		}
+		return n <= across
+	}
+	var lines []string
+	line := ""
+	words := strings.Fields(text)
+	for i := 0; i < len(words); i++ {
+		word := words[i]
+		if word == ":" && i+1 < len(words) && !fits(line, ": "+words[i+1]) && fits("", ": "+words[i+1]) {
+			word, i = ": "+words[i+1], i+1
+		}
+		if line != "" && fits(line, word) {
+			line += " " + word
+			continue
+		}
+		if line != "" {
+			lines = append(lines, line)
+		}
+		runes := []rune(word)
+		for len(runes) > across {
+			lines = append(lines, string(runes[:across]))
+			runes = runes[across:]
+		}
+		line = string(runes)
+	}
+	if line != "" || len(lines) == 0 {
+		lines = append(lines, line)
+	}
+	return lines
+}
+
+// dotEscapeLines joins lines as HTML-like label text, each escaped.
+func dotEscapeLines(lines []string) string {
+	escaped := make([]string, len(lines))
+	for i, line := range lines {
+		escaped[i] = dotEscape(line)
+	}
+	return strings.Join(escaped, "<br/>")
+}
+
+// dotSized wraps label text in a `<font point-size>` when its size is not the
+// node's 14pt default.
+func dotSized(size float64, text string) string {
+	if size == dotFontSize {
+		return text
+	}
+	return fmt.Sprintf(`<font point-size="%s">%s</font>`, formatCoord(size), text)
+}
+
 // dotPin pins a node at a pixel point: `pos="x,y!"` and `pin=true`.
 func (w *dotWriter) dotPin(centre Point) string {
 	return fmt.Sprintf("pos=%s, pin=true", dotQuote(w.dotPoint(centre)+"!"))
@@ -525,11 +945,18 @@ func (w *dotWriter) dotAnchorAttributes(node *Node) []string {
 // dotInvisibleAttributes draw a node as nothing: a cluster's anchor, a canvas corner.
 var dotInvisibleAttributes = []string{"shape=point", "style=invis", "width=0", "height=0", `label=""`}
 
-// dotClusterAttributes is a cluster's attribute statements: its label, a dashed
-// border for an orthogonal region, its black border at the skin's thickness (a
-// package's heavier than an element's), and its box as `bb` when it has an extent.
+// dotClusterAttributes is a cluster's attribute statements: its label (fitted to
+// its headroom when its box is stated, at the least one line at the floor, since a
+// cluster's label has no outside to go to), a dashed border for an orthogonal
+// region, its black border at the skin's thickness (a package's heavier than an
+// element's), and its box as `bb` when it has an extent.
 func (w *dotWriter) dotClusterAttributes(node *Node) []string {
-	attrs := []string{w.labels.dotLabel(node)}
+	label := w.labels.dotLabel(node)
+	if g := node.Geometry; g != nil && g.HasSize {
+		height, _ := w.headroom(node)
+		label = w.labels.dotFittedLabel(node, g.Width, math.Max(height, dotFitFloor*dotLineEm))
+	}
+	attrs := []string{label}
 	if node.Kind == "region" {
 		attrs = append(attrs, "style=dashed")
 	}
@@ -563,7 +990,7 @@ func (w *dotWriter) clusterBox(node *Node) nodeBox {
 	g := node.Geometry
 	corner := Point{X: g.X, Y: g.Y}
 	if g.HasSize {
-		return nodeBox{low: corner, high: Point{X: g.X + g.Width, Y: g.Y + g.Height}}
+		return nodeBox{low: corner, high: Point{X: g.X + g.Width, Y: g.Y + g.Height}, stated: true}
 	}
 	box := nodeBox{low: corner, high: corner}
 	if members := w.membersBox(node); members != nil {
@@ -650,7 +1077,7 @@ func (l labeller) dotLabel(node *Node) string {
 	for _, line := range lines[1:] {
 		parts = append(parts, dotEscape(line))
 	}
-	if node.Name != "" {
+	if keyworded(node) {
 		parts[1] = fmt.Sprintf(`<font point-size="%d"><i>%s</i></font>`, dotKeywordPointSize, parts[1])
 	}
 	return dotLabelAttribute("<" + strings.Join(parts, "<br/>") + ">")
diff --git a/internal/ir/view/dot_fit_test.go b/internal/ir/view/dot_fit_test.go
new file mode 100644
index 000000000..a4593dbaf
--- /dev/null
+++ b/internal/ir/view/dot_fit_test.go
@@ -0,0 +1,366 @@
+package view
+
+import (
+	"strings"
+	"testing"
+)
+
+// stated is a node pinned in a box of the given size, the geometry a Layout states.
+func stated(node *Node, width, height float64) *Node {
+	node.Geometry = &Geometry{X: 0, Y: 0, Width: width, Height: height, HasSize: true}
+	return node
+}
+
+// A label composed for a stated box fits it: the head word-wraps at the box's
+// width, keeps 14pt while the wrapped lines fit the height and shrinks a point at
+// a time to 8pt when they do not; the keyword and detail lines follow only while
+// height remains; a head that overruns at 8pt is cut to the lines that fit and
+// ellipsized. The box itself is never resized, and its margin is zeroed so the
+// whole box is the label's, as the fit assumes.
+func TestDOTFitsTheLabelToAStatedBox(t *testing.T) {
+	cases := []struct {
+		name string
+		node *Node
+		want string
+	}{
+		{"room for everything", stated(&Node{ID: "n", Kind: "action", Name: "call", Type: "doTracking"}, 200, 80),
+			`label=<<b>call : doTracking</b><br/><font point-size="10"><i>«action»</i></font>>, margin=0, pos="100,-40!", pin=true, width=2.7777777777777777, height=1.1111111111111112, fixedsize=true];`},
+		{"head wraps at the width", stated(&Node{ID: "n", Kind: "action", Name: "Execute Find and Identify Algorithm"}, 100, 100),
+			`label=<<b>Execute<br/>Find and<br/>Identify<br/>Algorithm</b><br/><font point-size="10"><i>«action»</i></font>>`},
+		{"keyword dropped for want of height", stated(&Node{ID: "n", Kind: "action", Name: "call", Type: "doTracking"}, 200, 24),
+			`label=<<b>call : doTracking</b>>`},
+		{"detail only while height remains", stated(&Node{ID: "n", Kind: "state", Name: "idle", Detail: "entry, do"}, 200, 40),
+			`label=<<b>idle</b><br/><font point-size="10"><i>«state»</i></font>>`},
+		{"detail when it fits", stated(&Node{ID: "n", Kind: "state", Name: "idle", Detail: "entry, do"}, 200, 60),
+			`label=<<b>idle</b><br/><font point-size="10"><i>«state»</i></font><br/>entry, do>`},
+		{"a compartment row shrinks to one line", stated(&Node{ID: "n", Kind: "attribute", Name: "errorReq", Type: "Real"}, 449, 14),
+			`label=<<font point-size="11"><b>errorReq : Real</b></font>>, margin=0, pos="224.5,-7!", pin=true, width=6.236111111111111, height=0.19444444444444445, fixedsize=true];`},
+		{"a name too long for the floor is ellipsized", stated(&Node{ID: "n", Kind: "attribute", Name: "'a name that runs on well past the width of the row it is drawn in'"}, 120, 14),
+			`label=<<font point-size="8"><b>&#39;a name that runs on…</b></font>>, margin=0, pos="60,-7!", pin=true, width=1.6666666666666667, height=0.19444444444444445, fixedsize=true];`},
+		{"a word wider than the box is broken across lines", stated(&Node{ID: "n", Kind: "action", Name: "Reconfiguration"}, 60, 60),
+			`label=<<b>Reconf<br/>igurat<br/>ion</b>>`},
+		{"shrinking to keep a word whole comes before breaking it", stated(&Node{ID: "n", Kind: "part", Name: "EventStream"}, 77, 32),
+			`label=<<font point-size="10"><b>EventStream</b></font><br/><font point-size="7"><i>«part»</i></font>>`},
+		{"wrapping comes before shrinking", stated(&Node{ID: "n", Kind: "part", Name: "pump", Type: "Pump"}, 60, 40),
+			`label=<<b>pump<br/>: Pump</b>>`},
+		// Twenty bold 14pt glyphs measure 184.8pt: the whole width is the label's, no margin off it.
+		{"a head filling the width keeps its size", stated(&Node{ID: "n", Kind: "action", Name: "doughboundhoundpound"}, 185, 20),
+			`label=<<b>doughboundhoundpound</b>>, margin=0, pos="92.5,-10!"`},
+		{"a head a point over the width shrinks", stated(&Node{ID: "n", Kind: "action", Name: "doughboundhoundpound"}, 184, 20),
+			`label=<<font point-size="13"><b>doughboundhoundpound</b></font>>, margin=0, pos="92,-10!"`},
+	}
+	for _, tc := range cases {
+		dot, err := (&Rendering{View: "V", Kind: KindAction, Roots: []*Node{tc.node}}).DOT()
+		if err != nil {
+			t.Fatalf("%s: DOT: %v", tc.name, err)
+		}
+		checkDOTSyntax(t, dot)
+		if !strings.Contains(dot, tc.want) {
+			t.Errorf("%s: DOT lacks %q:\n%s", tc.name, tc.want, dot)
+		}
+		if !strings.Contains(dot, "fixedsize=true") {
+			t.Errorf("%s: the stated box is not fixed:\n%s", tc.name, dot)
+		}
+		if !strings.Contains(dot, ", margin=0, ") {
+			t.Errorf("%s: the stated box keeps Graphviz's margin, which the fit did not allow for:\n%s", tc.name, dot)
+		}
+	}
+	// A node with no stated size keeps the label-fitted box and the plain label.
+	loose := &Node{ID: "n", Kind: "action", Name: "Execute Find and Identify Algorithm", Geometry: &Geometry{X: 0, Y: 0}}
+	dot, err := (&Rendering{View: "V", Kind: KindAction, Roots: []*Node{loose}}).DOT()
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	if want := `label=<<b>Execute Find and Identify Algorithm</b><br/><font point-size="10"><i>«action»</i></font>>, pos="`; !strings.Contains(dot, want) || strings.Contains(dot, "fixedsize") {
+		t.Errorf("unsized node's DOT lacks %q or fixes its size:\n%s", want, dot)
+	}
+}
+
+// The fitting estimates with the writer's glyph metrics: dotFitHead wraps a
+// head at the runes a bold line of the size holds and picks the largest size
+// whose wrapped lines stack within the height, with every word whole where a
+// size down to the floor allows it.
+func TestDOTFitHead(t *testing.T) {
+	cases := []struct {
+		head          string
+		width, height float64
+		size          float64
+		lines         []string
+		fits          bool
+	}{
+		{"call : doTracking", 200, 80, 14, []string{"call : doTracking"}, true},
+		{"call : doTracking", 100, 80, 14, []string{"call :", "doTracking"}, true},
+		{"call : doTracking", 100, 20, 8, []string{"call : doTracking"}, true},
+		{"errorReq : Real", 449, 14, 11, []string{"errorReq : Real"}, true},
+		{"EventStream", 77, 32, 10, []string{"EventStream"}, true},
+		{"Reconfiguration", 60, 60, 14, []string{"Reconf", "igurat", "ion"}, true},
+		{"abcdefghijklmnopqrstuvwxyz", 40, 14, 8, []string{"abcdef…"}, false},
+		{"abcdefghijklmnopqrstuvwxyz", 40, 30, 8, []string{"abcdefg", "hijklmn", "opqrst…"}, false},
+	}
+	for _, tc := range cases {
+		size, lines, fits := dotFitHead(tc.head, tc.width, tc.height)
+		if size != tc.size || fits != tc.fits || strings.Join(lines, "|") != strings.Join(tc.lines, "|") {
+			t.Errorf("dotFitHead(%q, %v, %v) = %v, %q, %v; want %v, %q, %v", tc.head, tc.width, tc.height, size, lines, fits, tc.size, tc.lines, tc.fits)
+		}
+	}
+	for _, tc := range []struct {
+		text   string
+		across int
+		want   []string
+	}{
+		{"a b c", 3, []string{"a b", "c"}},
+		{"a b c", 1, []string{"a", "b", "c"}},
+		{"abcdef gh", 4, []string{"abcd", "ef", "gh"}},
+		{"  spaced   out  ", 10, []string{"spaced out"}},
+		{"", 5, []string{""}},
+		{"call : Pump", 6, []string{"call", ": Pump"}},
+		{": Pump", 6, []string{": Pump"}},
+		{"a :", 1, []string{"a", ":"}},
+	} {
+		if got := dotWrap(tc.text, tc.across); strings.Join(got, "|") != strings.Join(tc.want, "|") {
+			t.Errorf("dotWrap(%q, %d) = %q, want %q", tc.text, tc.across, got, tc.want)
+		}
+	}
+}
+
+// A symbol kind in a stated box is drawn as its notation with no text inside:
+// decision, merge and choice a diamond, fork and join a filled bar, initial a
+// filled dot, final and a terminate action the double ring, a port its square.
+// A name the rendering has is set beside the symbol; a synthesized one is not
+// drawn. Without a stated box the kinds keep their labelled shapes.
+func TestDOTSymbolsInStatedBoxes(t *testing.T) {
+	cases := []struct {
+		name string
+		node *Node
+		want string
+	}{
+		{"decision", stated(&Node{ID: "n", Kind: "decision", Name: "decide2", NameSynthesized: true}, 24, 12),
+			`"n" [shape=diamond, label="", pos="12,-6!", pin=true, width=0.3333333333333333, height=0.16666666666666666, fixedsize=true];`},
+		{"merge", stated(&Node{ID: "n", Kind: "merge"}, 24, 12), `"n" [shape=diamond, label="", pos=`},
+		{"choice", stated(&Node{ID: "n", Kind: "choice", Name: "which"}, 24, 12), `"n" [shape=diamond, label="", xlabel="which", pos=`},
+		{"fork", stated(&Node{ID: "n", Kind: "fork", Name: "fork", NameSynthesized: true}, 120, 6),
+			`"n" [fillcolor=black, label="", pos="60,-3!", pin=true, width=1.6666666666666667, height=0.08333333333333333, fixedsize=true];`},
+		{"join", stated(&Node{ID: "n", Kind: "join", Name: "sync"}, 120, 6), `"n" [fillcolor=black, label="", xlabel="sync", pos=`},
+		{"initial", stated(&Node{ID: "n", Kind: "initial", Name: "start", NameSynthesized: true}, 20, 20),
+			`"n" [shape=circle, fillcolor=black, label="", pos="10,-10!", pin=true, width=0.2777777777777778, height=0.2777777777777778, fixedsize=true];`},
+		{"final", stated(&Node{ID: "n", Kind: "final", Name: "final", NameSynthesized: true}, 20, 20),
+			`"n" [shape=doublecircle, fillcolor=black, label="", pos=`},
+		{"terminate action", stated(&Node{ID: "n", Kind: terminateKind, Name: "final", NameSynthesized: true}, 20, 20),
+			`"n" [shape=doublecircle, fillcolor=black, label="", pos=`},
+		{"named final", stated(&Node{ID: "n", Kind: "final", Name: "done"}, 20, 20),
+			`"n" [shape=doublecircle, fillcolor=black, label="", xlabel="done", pos=`},
+		{"junction", stated(&Node{ID: "n", Kind: "junction", Name: "j"}, 16, 16),
+			`"n" [shape=circle, fillcolor=black, label="", xlabel="j", pos=`},
+		{"port", stated(&Node{ID: "n", Kind: "port", Name: "cmdIn", Type: "CmdPort"}, 12, 12),
+			`"n" [label="", xlabel="cmdIn : CmdPort", pos="6,-6!", pin=true, width=0.16666666666666666, height=0.16666666666666666, fixedsize=true];`},
+		{"ref port", stated(&Node{ID: "n", Kind: "ref port", Name: "p"}, 12, 12), `"n" [label="", xlabel="p", pos=`},
+		{"typed anonymous port", stated(&Node{ID: "n", Kind: "port", Type: "DataPort"}, 12, 12), `"n" [label="", xlabel=": DataPort", pos=`},
+		{"typed synthesized-name port", stated(&Node{ID: "n", Kind: "port", Name: "port2", NameSynthesized: true, Type: "DataPort"}, 12, 12),
+			`"n" [label="", xlabel=": DataPort", pos=`},
+		{"untyped anonymous port", stated(&Node{ID: "n", Kind: "port"}, 12, 12), `"n" [label="", pos=`},
+	}
+	for _, tc := range cases {
+		dot, err := (&Rendering{View: "V", Kind: KindAction, Roots: []*Node{tc.node}}).DOT()
+		if err != nil {
+			t.Fatalf("%s: DOT: %v", tc.name, err)
+		}
+		checkDOTSyntax(t, dot)
+		if !strings.Contains(dot, tc.want) {
+			t.Errorf("%s: DOT lacks %q:\n%s", tc.name, tc.want, dot)
+		}
+		if strings.Contains(dot, "«") {
+			t.Errorf("%s: a symbol carries a keyword line:\n%s", tc.name, dot)
+		}
+	}
+	// A port under a palette keeps its family fill, so the square is coloured.
+	dot, err := (&Rendering{View: "V", Kind: KindInterconnection, Roots: []*Node{stated(&Node{ID: "n", Kind: "port", Name: "p"}, 12, 12)}}).DOTWith(Options{Palette: PaletteOkabeIto})
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	if want := `"n" [fillcolor="#99D8C7", color="#009E73", penwidth=1, label="", xlabel="p", pos=`; !strings.Contains(dot, want) {
+		t.Errorf("palette port DOT lacks %q:\n%s", want, dot)
+	}
+	// A port def is a definition, not a symbol; a symbol kind with no stated size
+	// is labelled as before.
+	for _, tc := range []struct {
+		name string
+		node *Node
+		want string
+	}{
+		{"port def", stated(&Node{ID: "n", Kind: "port def", Name: "CmdPort"}, 120, 40),
+			`label=<<b>CmdPort</b><br/><font point-size="10"><i>«port def»</i></font>>`},
+		{"unsized decision", &Node{ID: "n", Kind: "decision", Name: "decide", Geometry: &Geometry{X: 5, Y: 5}},
+			`"n" [label=<<b>decide</b><br/><font point-size="10"><i>«decision»</i></font>>, pos=`},
+		{"unsized terminate action", &Node{ID: "n", Kind: terminateKind, Name: "final"},
+			`"n" [style="rounded,filled", label=<<b>final</b><br/><font point-size="10"><i>«terminate action»</i></font>>];`},
+		{"unsized named initial", &Node{ID: "n", Kind: "initial", Name: "begin"},
+			`"n" [shape=circle, label=<<b>begin</b><br/><font point-size="10"><i>«initial»</i></font>>];`},
+		{"unsized initial with a synthesized name", &Node{ID: "n", Kind: "initial", Name: "start", NameSynthesized: true},
+			`"n" [shape=circle, fillcolor=black, label="", width=0.2];`},
+	} {
+		dot, err := (&Rendering{View: "V", Kind: KindAction, Roots: []*Node{tc.node}}).DOT()
+		if err != nil {
+			t.Fatalf("%s: DOT: %v", tc.name, err)
+		}
+		if !strings.Contains(dot, tc.want) {
+			t.Errorf("%s: DOT lacks %q:\n%s", tc.name, tc.want, dot)
+		}
+	}
+}
+
+// A synthesized name is drawn nowhere: a plain node with one is drawn as its
+// source drew it, unnamed, so a typed one reads ": Type" and an untyped one its kind.
+func TestDOTSynthesizedNameOnAPlainNode(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		node *Node
+		want string
+	}{
+		{"typed", &Node{ID: "n", Kind: "action", Name: "call", Type: "doTracking", NameSynthesized: true},
+			`label=<<b>: doTracking</b><br/><font point-size="10"><i>«action»</i></font>>`},
+		{"untyped", &Node{ID: "n", Kind: "action", Name: "send2", NameSynthesized: true}, `label=<<b>action</b>>`},
+	} {
+		dot, err := (&Rendering{View: "V", Kind: KindAction, Roots: []*Node{stated(tc.node, 140, 40)}}).DOT()
+		if err != nil {
+			t.Fatalf("%s: DOT: %v", tc.name, err)
+		}
+		if !strings.Contains(dot, tc.want) {
+			t.Errorf("%s: DOT lacks %q:\n%s", tc.name, tc.want, dot)
+		}
+	}
+}
+
+// A stated box is written before the stated boxes it encloses, whatever order
+// the rendering lists them in, so Graphviz paints the enclosed ones on top;
+// boxes that do not nest, and boxes not stated (here the strip's), keep the
+// rendering's order.
+func TestDOTWritesAnEnclosingBoxFirst(t *testing.T) {
+	inner := &Node{ID: "inner", Kind: "part", Name: "sensor", Geometry: &Geometry{X: 20, Y: 20, Width: 60, Height: 30, HasSize: true}}
+	outer := &Node{ID: "outer", Kind: "part", Name: "bench", Geometry: &Geometry{X: 0, Y: 0, Width: 300, Height: 200, HasSize: true}}
+	beside := &Node{ID: "beside", Kind: "part", Name: "rack", Geometry: &Geometry{X: 400, Y: 0, Width: 60, Height: 30, HasSize: true}}
+	loose := &Node{ID: "loose", Kind: "part", Name: "spare"}
+	dot, err := (&Rendering{View: "V", Kind: KindInterconnection, Roots: []*Node{inner, beside, loose, outer}}).DOTWith(Options{Unplaced: UnplacedStrip})
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	checkDOTSyntax(t, dot)
+	last := -1
+	for _, id := range []string{"outer", "inner", "beside", "loose"} {
+		at := strings.Index(dot, "\n  "+dotQuote(id)+" [")
+		if at < 0 {
+			t.Fatalf("DOT lacks node %q:\n%s", id, dot)
+		}
+		if at < last {
+			t.Errorf("node %q written out of draw order:\n%s", id, dot)
+		}
+		last = at
+	}
+}
+
+// A stated box that holds other stated boxes keeps its title in the strip above
+// the topmost of them, as the notation's header compartment does: the label is
+// fitted to that strip's height and set at the top, so no member covers it. A
+// box holding none, or with a name too long for the strip, is fitted as before,
+// to the whole box, or cut to the strip and ellipsized; a strip too thin for one
+// line at the floor sets the head outside the box instead. A stated box drawn as
+// a cluster round its children is fitted the same way.
+func TestDOTHeadsAnEnclosingBoxAboveItsMembers(t *testing.T) {
+	// Cameo's IBD: a 300×200 part with two members from 40px down, a third box beside it.
+	member := func(id string, x, y float64) *Node {
+		return &Node{ID: id, Kind: "part", Name: id, Geometry: &Geometry{X: x, Y: y, Width: 80, Height: 30, HasSize: true}}
+	}
+	outer := &Node{ID: "outer", Kind: "part", Name: "'summit Installation'", Type: "'Summit Installation'",
+		Geometry: &Geometry{X: 0, Y: 0, Width: 300, Height: 200, HasSize: true}}
+	beside := &Node{ID: "beside", Kind: "part", Name: "rack", Geometry: &Geometry{X: 400, Y: 0, Width: 300, Height: 200, HasSize: true}}
+	dot, err := (&Rendering{View: "V", Kind: KindInterconnection, Roots: []*Node{outer, member("computer", 20, 60), member("sensor", 120, 40), beside}}).DOT()
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	checkDOTSyntax(t, dot)
+	for _, want := range []string{
+		// The 40px strip holds the head wrapped to two 14pt lines (33.6px), not the keyword line too; the label sits at the top.
+		`"outer" [style="rounded,filled", label=<<b>&#39;summit Installation&#39; : &#39;Summit<br/>Installation&#39;</b>>, margin=0, labelloc=t, pos="150,-100!", pin=true, width=4.166666666666667, height=2.7777777777777777, fixedsize=true];`,
+		// A box holding nothing is fitted to the whole of it and centred; the members keep their stated boxes.
+		`"beside" [style="rounded,filled", label=<<b>rack</b><br/><font point-size="10"><i>«part»</i></font>>, margin=0, pos="550,-100!"`,
+		`"computer" [style="rounded,filled", label=<<b>computer</b><br/><font point-size="10"><i>«part»</i></font>>, margin=0, pos="60,-75!", pin=true, width=1.1111111111111112, height=0.4166666666666667, fixedsize=true];`,
+	} {
+		if !strings.Contains(dot, want) {
+			t.Errorf("DOT lacks %q:\n%s", want, dot)
+		}
+	}
+	// A node the Layout only places, its box sized to its label, is no member: the title is fitted to the whole box.
+	placed := &Node{ID: "loose", Kind: "action", Name: "spare", Geometry: &Geometry{X: 20, Y: 20}}
+	dot, err = (&Rendering{View: "V", Kind: KindInterconnection, Roots: []*Node{outer, placed}}).DOT()
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	if want := `"outer" [style="rounded,filled", label=<<b>&#39;summit Installation&#39; : &#39;Summit<br/>Installation&#39;</b><br/><font point-size="10"><i>«part»</i></font>>, margin=0, pos="150,-100!"`; !strings.Contains(dot, want) {
+		t.Errorf("DOT lacks %q:\n%s", want, dot)
+	}
+	// A member 10px below the top leaves the title one 8pt line, cut to the width and ellipsized.
+	narrow := &Node{ID: "outer", Kind: "part", Name: outer.Name, Type: outer.Type, Geometry: &Geometry{X: 0, Y: 0, Width: 150, Height: 200, HasSize: true}}
+	dot, err = (&Rendering{View: "V", Kind: KindInterconnection, Roots: []*Node{narrow, member("computer", 20, 10)}}).DOT()
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	if want := `"outer" [style="rounded,filled", label=<<font point-size="8"><b>&#39;summit Installation&#39;…</b></font>>, margin=0, labelloc=t, pos="75,-100!"`; !strings.Contains(dot, want) {
+		t.Errorf("DOT lacks %q:\n%s", want, dot)
+	}
+	// A member 9px below the top leaves no room for a line even at the floor: the head is set outside.
+	dot, err = (&Rendering{View: "V", Kind: KindInterconnection, Roots: []*Node{narrow, member("computer", 20, 9)}}).DOT()
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	if want := `"outer" [style="rounded,filled", label="", xlabel="'summit Installation' : 'Summit Installation'", pos="75,-100!"`; !strings.Contains(dot, want) {
+		t.Errorf("DOT lacks %q:\n%s", want, dot)
+	}
+	// A cluster's label is fitted to its stated box the same way: the title wrapped
+	// to the 40px strip above its child, the keyword line left out.
+	framed := &Node{ID: "outer", Kind: "part", Name: outer.Name, Type: outer.Type, Geometry: outer.Geometry, Children: []*Node{member("computer", 20, 40)}}
+	dot, err = (&Rendering{View: "V", Kind: KindInterconnection, Roots: []*Node{framed}}).DOT()
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	checkDOTSyntax(t, dot)
+	if want := "subgraph \"cluster_outer\" {\n    label=<<b>&#39;summit Installation&#39; : &#39;Summit<br/>Installation&#39;</b>>;\n"; !strings.Contains(dot, want) {
+		t.Errorf("DOT lacks %q:\n%s", want, dot)
+	}
+	// A cluster's label has no outside to go to: a strip thinner than a line still gets one line at the floor.
+	framed.Children[0].Geometry.Y = 4
+	dot, err = (&Rendering{View: "V", Kind: KindInterconnection, Roots: []*Node{framed}}).DOT()
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	if want := "subgraph \"cluster_outer\" {\n    label=<<font point-size=\"8\"><b>&#39;summit Installation&#39; : &#39;Summit Installation&#39;</b></font>>;\n"; !strings.Contains(dot, want) {
+		t.Errorf("DOT lacks %q:\n%s", want, dot)
+	}
+}
+
+// A stated box too short for one line at the floor, or too narrow for one glyph,
+// holds no text: its head is set outside as `xlabel`, as a symbol's is, and a
+// box with nothing but its kind to show is left bare.
+func TestDOTSetsATinyBoxsHeadOutside(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		node *Node
+		want string
+	}{
+		{"short", &Node{ID: "n", Kind: "action", Name: "tick", Geometry: &Geometry{X: 0, Y: 0, Width: 20, Height: 6, HasSize: true}},
+			`"n" [style="rounded,filled", label="", xlabel="tick", pos="10,-3!", pin=true, width=0.2777777777777778, height=0.08333333333333333, fixedsize=true];`},
+		{"narrow", &Node{ID: "n", Kind: "part", Type: "Pump", Geometry: &Geometry{X: 0, Y: 0, Width: 4, Height: 40, HasSize: true}},
+			`"n" [style="rounded,filled", label="", xlabel=": Pump", pos="2,-20!"`},
+		{"bare", &Node{ID: "n", Kind: "action", Geometry: &Geometry{X: 0, Y: 0, Width: 20, Height: 6, HasSize: true}},
+			`"n" [style="rounded,filled", label="", pos="10,-3!"`},
+		{"one line", &Node{ID: "n", Kind: "action", Name: "tick", Geometry: &Geometry{X: 0, Y: 0, Width: 30, Height: 10, HasSize: true}},
+			`"n" [style="rounded,filled", label=<<font point-size="8"><b>tick</b></font>>, margin=0, pos="15,-5!"`},
+	} {
+		dot, err := (&Rendering{View: "V", Kind: KindInterconnection, Roots: []*Node{tc.node}}).DOT()
+		if err != nil {
+			t.Fatalf("%s: DOT: %v", tc.name, err)
+		}
+		checkDOTSyntax(t, dot)
+		if !strings.Contains(dot, tc.want) {
+			t.Errorf("%s: DOT lacks %q:\n%s", tc.name, tc.want, dot)
+		}
+	}
+}
diff --git a/internal/ir/view/dot_style_test.go b/internal/ir/view/dot_style_test.go
index 3a8705432..f667da684 100644
--- a/internal/ir/view/dot_style_test.go
+++ b/internal/ir/view/dot_style_test.go
@@ -132,8 +132,9 @@ func TestDOTClusterBorders(t *testing.T) {
 				Geometry: &Geometry{X: 0, Y: 0, HasSize: true, Width: 100, Height: 50}},
 		}},
 	}}
+	// body is placed, so the rest is drawn only when asked for, in the strip.
 	for _, palette := range []Palette{"", PaletteTolBright} {
-		dot, err := rendering.DOTWith(Options{Palette: palette})
+		dot, err := rendering.DOTWith(Options{Palette: palette, Unplaced: UnplacedStrip})
 		if err != nil {
 			t.Fatalf("DOT: %v", err)
 		}
@@ -207,22 +208,23 @@ func TestDOTPaletteFills(t *testing.T) {
 			{ID: "n6", Kind: "view", Name: "v"},
 		}},
 	}, Edges: []Edge{{From: "n1", To: "n2", Kind: EdgeConnection}}}
-	plain, err := rendering.DOT()
+	// p is placed, so the rest is drawn only when asked for, in the strip.
+	plain, err := rendering.DOTWith(Options{Unplaced: UnplacedStrip})
 	if err != nil {
 		t.Fatalf("DOT: %v", err)
 	}
-	dot, err := rendering.DOTWith(Options{Palette: PaletteOkabeIto})
+	dot, err := rendering.DOTWith(Options{Palette: PaletteOkabeIto, Unplaced: UnplacedStrip})
 	if err != nil {
 		t.Fatalf("DOT: %v", err)
 	}
 	checkDOTSyntax(t, dot)
 	part, port, item, other := paletteColors[PaletteOkabeIto][0], paletteColors[PaletteOkabeIto][2], paletteColors[PaletteOkabeIto][1], paletteColors[PaletteOkabeIto][18%8]
 	for _, want := range []string{
-		`"n1" [style="rounded,filled", fillcolor="` + paletteFill(part, true) + `", color="` + part + `", penwidth=1, label=<<b>p</b><br/><font point-size="10"><i>«part»</i></font>>, pos="60,-45!", pin=true, width=1.3888888888888888, height=0.6944444444444444, fixedsize=true];`,
+		`"n1" [style="rounded,filled", fillcolor="` + paletteFill(part, true) + `", color="` + part + `", penwidth=1, label=<<b>p</b><br/><font point-size="10"><i>«part»</i></font>>, margin=0, pos="60,-45!", pin=true, width=1.3888888888888888, height=0.6944444444444444, fixedsize=true];`,
 		`"n2" [style="rounded,filled", fillcolor="` + paletteFill(port, true) + `", color="` + port + `", penwidth=1, label=`,
 		`"n3" [fillcolor="` + item + `", color="` + item + `", penwidth=1, label=`,
-		`"n4" [shape=circle, fillcolor=black, label="", width=0.2];`,
-		`"n5" [shape=point, fillcolor=black, label=""];`,
+		`"n4" [shape=circle, fillcolor=black, label="", pos=`,
+		`"n5" [shape=point, fillcolor=black, label="", pos=`,
 		`"n6" [style="rounded,filled", fillcolor="` + paletteFill(other, true) + `", color="` + other + `", penwidth=1, label=`,
 		"    label=<<b>Def</b><br/><font point-size=\"10\"><i>«part def»</i></font>>;\n    color=black;\n    penwidth=0.5;\n",
 		`"n1" -> "n2" [arrowhead=none, penwidth=3];`,
@@ -244,7 +246,7 @@ func TestDOTPaletteFills(t *testing.T) {
 		t.Errorf("palette changes more than fills:\n%s\nblack and white:\n%s", dot, plain)
 	}
 	// A tree fills the nodes that an interconnection draws as clusters.
-	tree, err := (&Rendering{View: "V", Kind: KindTree, Roots: rendering.Roots}).DOTWith(Options{Palette: PaletteOkabeIto})
+	tree, err := (&Rendering{View: "V", Kind: KindTree, Roots: rendering.Roots}).DOTWith(Options{Palette: PaletteOkabeIto, Unplaced: UnplacedStrip})
 	if err != nil {
 		t.Fatalf("DOT: %v", err)
 	}
diff --git a/internal/ir/view/dot_test.go b/internal/ir/view/dot_test.go
index d0dfb7589..370385a91 100644
--- a/internal/ir/view/dot_test.go
+++ b/internal/ir/view/dot_test.go
@@ -175,7 +175,10 @@ func TestDOTLabelShape(t *testing.T) {
 		{"definition", &Node{Kind: "part def", Name: "Plant::Loop"},
 			`<<b>Plant::Loop</b><br/><font point-size="10"><i>«part def»</i></font>>`},
 		{"name-less", &Node{Kind: "connect"}, `<<b>connect</b>>`},
-		{"name-less typed", &Node{Kind: "part", Type: "Pump"}, `<<b>part</b>>`},
+		{"name-less typed", &Node{Kind: "part", Type: "Pump"}, `<<b>: Pump</b><br/><font point-size="10"><i>«part»</i></font>>`},
+		{"synthesized name", &Node{Kind: "action", Name: "call", Type: "doTracking", NameSynthesized: true},
+			`<<b>: doTracking</b><br/><font point-size="10"><i>«action»</i></font>>`},
+		{"synthesized name, untyped", &Node{Kind: "action", Name: "stamp2", NameSynthesized: true}, `<<b>action</b>>`},
 		{"name-less with note", &Node{Kind: "connect", Detail: "already shown"}, `<<b>connect</b><br/>already shown>`},
 		{"notes", &Node{Kind: "part", Name: "sensor", Type: "Pump", Detail: "already shown as n1, collapsed"},
 			`<<b>sensor : Pump</b><br/><font point-size="10"><i>«part»</i></font><br/>already shown as n1, collapsed>`},
@@ -482,7 +485,7 @@ func TestDOTWritesTheGeometry(t *testing.T) {
 		// to eleven 14pt glyphs over a 10pt keyword line, stated but not fixed, collapsed.
 		`"n1" [style="rounded,filled", label=<<b>pump : Pump</b><br/><font point-size="10"><i>«part»</i></font>>, pos="359,741.5!", pin=true, width=1.6388888888888888, height=0.5138888888888888, comment="collapsed"];`,
 		// tank: top-left (500, 40), 120x60, so centre (560, 70) -> y 730 from a canvas 800 high.
-		`"n2" [style="rounded,filled", label=<<b>tank : Tank</b><br/><font point-size="10"><i>«part»</i></font>>, pos="560,730!", pin=true, width=1.6666666666666667, height=0.8333333333333334, fixedsize=true];`,
+		`"n2" [style="rounded,filled", label=<<b>tank : Tank</b><br/><font point-size="10"><i>«part»</i></font>>, margin=0, pos="560,730!", pin=true, width=1.6666666666666667, height=0.8333333333333334, fixedsize=true];`,
 		`"n1" -> "n2" [label="supply", arrowhead=none, penwidth=3, pos="400,730 400,730 450,680 450,680 450,680 500,730 500,730"];`,
 	} {
 		if !strings.Contains(dot, want) {
@@ -490,6 +493,7 @@ func TestDOTWritesTheGeometry(t *testing.T) {
 		}
 	}
 	// Without a canvas height, y is negated; the inline Layout of pump is kept,
+	// its head wrapped where eleven bold 14pt glyphs overrun the stated 100pt width,
 	// and tank, with none, takes the end of the inline route: its 118x37
 	// label-fitted box centred 59 back from (200, 45) along the route's last leg.
 	plain, err := render(t, "layout.sysml", "PlantViews::plainView").DOT()
@@ -500,7 +504,7 @@ func TestDOTWritesTheGeometry(t *testing.T) {
 	for _, want := range []string{
 		"// layout: neato -n2\ndigraph",
 		"  graph [fontname=\"Helvetica\", inputscale=72, dpi=72];\n",
-		`"n1" [style="rounded,filled", label=<<b>pump : Pump</b><br/><font point-size="10"><i>«part»</i></font>>, pos="60,-45!", pin=true, width=1.3888888888888888, height=0.6944444444444444, fixedsize=true];`,
+		`"n1" [style="rounded,filled", label=<<b>pump<br/>: Pump</b><br/><font point-size="10"><i>«part»</i></font>>, margin=0, pos="60,-45!", pin=true, width=1.3888888888888888, height=0.6944444444444444, fixedsize=true];`,
 		`"n2" [style="rounded,filled", label=<<b>tank : Tank</b><br/><font point-size="10"><i>«part»</i></font>>, pos="259,-45!", pin=true, width=1.6388888888888888, height=0.5138888888888888];`,
 		`pos="60,-45 60,-45 200,-45 200,-45"`,
 	} {
@@ -512,18 +516,20 @@ func TestDOTWritesTheGeometry(t *testing.T) {
 		t.Errorf("plain DOT states a canvas it has none of:\n%s", plain)
 	}
 	// States and transitions are placed the same way; the start, with neither
-	// a Layout nor a routed transition, is not, and leaves the graph to neato.
+	// a Layout nor a routed transition, is not, and is left undrawn with its edge.
 	machine, err := render(t, "layout.sysml", "PlantViews::machineView").DOT()
 	if err != nil {
 		t.Fatalf("DOT: %v", err)
 	}
 	checkDOTSyntax(t, machine)
+	if strings.Contains(machine, `"n3"`) {
+		t.Errorf("machine DOT draws the unplaced start:\n%s", machine)
+	}
 	for _, want := range []string{
-		"// layout: neato\ndigraph",
-		`"n3" [shape=point, fillcolor=black, label=""];`,
+		"// not represented: 1 node(s) without a position, left undrawn, and 1 edge(s) at them\n// layout: neato -n2\ndigraph",
 		// off: three lines, 14pt, 10pt and 14pt, so a 75x54 box from its top-left (0, 0).
 		`[style="rounded,filled", label=<<b>off</b><br/><font point-size="10"><i>«state»</i></font><br/>initial>, pos="37.5,-27!", pin=true, width=1.0416666666666667, height=0.75];`,
-		`[style="rounded,filled", label=<<b>on</b><br/><font point-size="10"><i>«state»</i></font>>, pos="40,-120!", pin=true, width=1.1111111111111112, height=0.5555555555555556, fixedsize=true];`,
+		`[style="rounded,filled", label=<<b>on</b><br/><font point-size="10"><i>«state»</i></font>>, margin=0, pos="40,-120!", pin=true, width=1.1111111111111112, height=0.5555555555555556, fixedsize=true];`,
 		`"n1" -> "n2" [label="off_on", pos="50,-10 50,-10 50,-90 50,-90"];`,
 		`"n2" -> "n1" [pos="30,-90 30,-90 30,-10 30,-10"];`,
 	} {
@@ -542,9 +548,10 @@ func TestDOTWritesTheGeometry(t *testing.T) {
 
 // A graph whose every node is positioned is written for `neato -n`, and for
 // `neato -n2` once any edge is routed; a route of one waypoint is noticed,
-// as are routes while a node is left for `neato` to place; a cluster
+// as is a node left unplaced, which is not drawn; a cluster
 // states its box — the stated one, or the one from its corner round its
-// members — and pins its anchor at the centre; a tree pins the node itself.
+// members — and pins its anchor at the centre; a stated cluster's label is
+// fitted to the strip above its topmost stated member; a tree pins the node itself.
 func TestDOTPinsEveryNode(t *testing.T) {
 	rendering := &Rendering{
 		View:   "Pinned::view",
@@ -581,13 +588,13 @@ digraph "Pinned::view" {
   "canvas:0" [shape=point, style=invis, width=0, height=0, label="", pos="0,300!", pin=true];
   "canvas:1" [shape=point, style=invis, width=0, height=0, label="", pos="400,0!", pin=true];
   subgraph "cluster_n0" {
-    label=<<b>Outer</b><br/><font point-size="10"><i>«part def»</i></font>>;
+    label=<<font point-size="8"><b>Outer</b></font>>;
     color=black;
     penwidth=0.5;
     bb="10,180,210,280";
     comment="collapsed";
     "n0" [shape=point, style=invis, width=0, height=0, label="", pos="110,230!", pin=true];
-    "n1" [style="rounded,filled", label=<<b>a</b><br/><font point-size="10"><i>«part»</i></font>>, pos="56,252!", pin=true, width=1, height=0.5, fixedsize=true];
+    "n1" [style="rounded,filled", label=<<b>a</b><br/><font point-size="10"><i>«part»</i></font>>, margin=0, pos="56,252!", pin=true, width=1, height=0.5, fixedsize=true];
     "n2" [style="rounded,filled", label=<<b>b</b><br/><font point-size="10"><i>«part»</i></font>>, pos="147,251.5!", pin=true, width=0.75, height=0.5138888888888888];
   }
   subgraph "cluster_n3" {
@@ -615,15 +622,14 @@ digraph "Pinned::view" {
 	if !strings.Contains(dot, "// layout: neato -n2\n") || !strings.Contains(dot, `"n2" -> "n3" [style=dashed, pos="174,252 174,252 300,80 300,80", lhead="cluster_n3"];`) || strings.Contains(dot, "not represented") {
 		t.Errorf("fully routed DOT:\n%s", dot)
 	}
-	// Leaving a node unpositioned hands the graph to `neato`, which redraws
-	// the routes it is given, so they are noticed.
+	// Leaving a node unpositioned leaves it undrawn, the rest pinned as before.
 	rendering.Roots[1].Children[0].Geometry = nil
 	dot, err = rendering.DOT()
 	if err != nil {
 		t.Fatalf("DOT: %v", err)
 	}
 	checkDOTSyntax(t, dot)
-	if !strings.Contains(dot, "// not represented: 2 route(s) written as pos; neato redraws every edge, only neato -n2 keeps them\n// canvas: unit=px w=400 h=300\n// layout: neato\n") {
+	if !strings.Contains(dot, "// not represented: 1 node(s) without a position, left undrawn\n// canvas: unit=px w=400 h=300\n// layout: neato -n2\n") || strings.Contains(dot, `"n4"`) {
 		t.Errorf("partly positioned DOT:\n%s", dot)
 	}
 	rendering.Roots[1].Children[0].Geometry = &Geometry{X: 310, Y: 210}
@@ -642,7 +648,8 @@ digraph "Pinned::view" {
 	for _, want := range []string{
 		"// layout: neato -n2\n",
 		"  graph [fontname=\"Helvetica\", inputscale=72, dpi=72];\n  node [shape=box, style=filled, fillcolor=white, color=\"#181818\", fontname=\"Helvetica\", fontsize=14, penwidth=0.5];\n  edge [color=\"#181818\", fontname=\"Helvetica\", fontsize=13, penwidth=1];\n  \"canvas:0\" [shape=point, style=invis, width=0, height=0, label=\"\", pos=\"0,300!\", pin=true];\n  \"canvas:1\" [shape=point, style=invis, width=0, height=0, label=\"\", pos=\"400,0!\", pin=true];\n  \"n0\"",
-		`"n0" [label=<<b>Outer</b><br/><font point-size="10"><i>«part def»</i></font>>, pos="110,230!", pin=true, width=2.7777777777777777, height=1.3888888888888888, fixedsize=true, comment="collapsed"];`,
+		// Outer's box holds a's, 10px below its top: its title is fitted to that strip, at the top.
+		`"n0" [label=<<font point-size="8"><b>Outer</b></font>>, margin=0, labelloc=t, pos="110,230!", pin=true, width=2.7777777777777777, height=1.3888888888888888, fixedsize=true, comment="collapsed"];`,
 		`"n3" [label=<<b>Other</b><br/><font point-size="10"><i>«part def»</i></font>>, pos="338,81.5!", pin=true, width=1.0555555555555556, height=0.5138888888888888];`,
 	} {
 		if !strings.Contains(dot, want) {
@@ -653,7 +660,8 @@ digraph "Pinned::view" {
 		t.Errorf("tree DOT states a cluster box:\n%s", dot)
 	}
 	// Pseudo-states are centred on their own shapes: a point's fixed size, a
-	// circle round the label's diagonal.
+	// circle round the label's diagonal, a stated box drawn as the bare symbol
+	// with the name beside it.
 	pseudo := &Rendering{View: "V", Kind: KindState, Roots: []*Node{
 		{ID: "s", Kind: startKind, Geometry: &Geometry{X: 0, Y: 0}},
 		{ID: "i", Kind: "initial", Name: "go", Geometry: &Geometry{X: 100, Y: 0}},
@@ -667,7 +675,7 @@ digraph "Pinned::view" {
 	for _, want := range []string{
 		`"s" [shape=point, fillcolor=black, label="", pos="1.8,-1.8!", pin=true];`,
 		`"i" [shape=circle, label=<<b>go</b><br/><font point-size="10"><i>«initial»</i></font>>, pos="140,-40!", pin=true, width=1.1111111111111112, height=1.1111111111111112];`,
-		`"f" [shape=doublecircle, label=<<b>done</b><br/><font point-size="10"><i>«final»</i></font>>, pos="205,-5!", pin=true, width=0.1388888888888889, height=0.1388888888888889, fixedsize=true];`,
+		`"f" [shape=doublecircle, fillcolor=black, label="", xlabel="done", pos="205,-5!", pin=true, width=0.1388888888888889, height=0.1388888888888889, fixedsize=true];`,
 	} {
 		if !strings.Contains(dot, want) {
 			t.Errorf("pseudo-state DOT lacks %q:\n%s", want, dot)
@@ -688,7 +696,7 @@ digraph "Pinned::view" {
 		}
 	}
 	// A cluster with a corner but no positioned member has no box to state;
-	// its anchor is pinned at the corner and neato places the members.
+	// its anchor is pinned at the corner and the unplaced member is left undrawn.
 	corner := &Rendering{View: "V", Kind: KindInterconnection, Roots: []*Node{
 		{ID: "n0", Kind: "part def", Name: "Outer", Geometry: &Geometry{X: 30, Y: 40}, Children: []*Node{{ID: "n1", Kind: "part", Name: "a"}}},
 	}}
@@ -697,7 +705,7 @@ digraph "Pinned::view" {
 		t.Fatalf("DOT: %v", err)
 	}
 	checkDOTSyntax(t, dot)
-	if !strings.Contains(dot, "// layout: neato\n") || strings.Contains(dot, "bb=") || !strings.Contains(dot, `"n0" [shape=point, style=invis, width=0, height=0, label="", pos="30,-40!", pin=true];`) {
+	if !strings.Contains(dot, "// layout: neato -n\n") || strings.Contains(dot, "bb=") || strings.Contains(dot, `"n1"`) || !strings.Contains(dot, `"n0" [shape=point, style=invis, width=0, height=0, label="", pos="30,-40!", pin=true];`) {
 		t.Errorf("corner-only cluster DOT:\n%s", dot)
 	}
 	// A canvas with a unit alone is named in the header and pins nothing, and
@@ -726,7 +734,7 @@ digraph "Pinned::view" {
 // The cluster round them is boxed a margin round every placed member. Every
 // node then has a position and the header names `neato -n2`; a stated Layout
 // still wins over the route, a one-point route places nothing, and a node with
-// neither Layout nor route leaves the graph to `neato` as before.
+// neither Layout nor route is left undrawn, with the edges at it.
 func TestDOTPlacesNodesFromRoutes(t *testing.T) {
 	rendering := &Rendering{
 		View:   "Routed::view",
@@ -773,7 +781,7 @@ digraph "Routed::view" {
     "n0" [shape=point, style=invis, width=0, height=0, label="", pos="157.75,165!", pin=true];
     "n1" [shape=circle, label=<<b>start</b><br/><font point-size="10"><i>«initial»</i></font>>, pos="160,313!", pin=true, width=1.1111111111111112, height=1.1111111111111112];
     "n2" [style="rounded,filled", label=<<b>wait</b><br/><font point-size="10"><i>«action»</i></font>>, pos="160,215.5!", pin=true, width=0.8888888888888888, height=0.5138888888888888];
-    "n3" [style="rounded,filled", label=<<b>send</b><br/><font point-size="10"><i>«action»</i></font>>, pos="160,106!", pin=true, width=1.1111111111111112, height=0.5555555555555556, fixedsize=true];
+    "n3" [style="rounded,filled", label=<<b>send</b><br/><font point-size="10"><i>«action»</i></font>>, margin=0, pos="160,106!", pin=true, width=1.1111111111111112, height=0.5555555555555556, fixedsize=true];
     "n4" [shape=doublecircle, label=<<b>done</b><br/><font point-size="10"><i>«final»</i></font>>, pos="150,11.5!", pin=true, width=0.9583333333333334, height=0.9583333333333334];
   }
   "n1" -> "n2" [pos="160,273 160,273 160,234 160,234"];
@@ -811,8 +819,8 @@ digraph "Routed::view" {
 		t.Fatalf("DOT: %v", err)
 	}
 	checkDOTSyntax(t, dot)
-	if !strings.Contains(dot, "// not represented: route of n3->n4 is one waypoint, (150, 240); a line needs two\n// not represented: 2 route(s) written as pos; neato redraws every edge, only neato -n2 keeps them\n// canvas: unit=px w=250 h=326\n// layout: neato\n") ||
-		!strings.Contains(dot, `"n4" [shape=doublecircle, label=<<b>done</b><br/><font point-size="10"><i>«final»</i></font>>];`) {
+	if !strings.Contains(dot, "// not represented: 1 node(s) without a position, left undrawn, and 1 edge(s) at them\n// canvas: unit=px w=250 h=326\n// layout: neato -n2\n") ||
+		strings.Contains(dot, `"n4"`) || strings.Contains(dot, "one waypoint") {
 		t.Errorf("one-waypoint DOT:\n%s", dot)
 	}
 	rendering.Edges = rendering.Edges[:2]
@@ -822,11 +830,11 @@ digraph "Routed::view" {
 		t.Fatalf("DOT: %v", err)
 	}
 	checkDOTSyntax(t, dot)
-	if !strings.Contains(dot, "// layout: neato\n") || !strings.Contains(dot, `"n5" [style="rounded,filled", label=<<b>value</b><br/><font point-size="10"><i>«action»</i></font>>];`) {
+	if !strings.Contains(dot, "// not represented: 2 node(s) without a position, left undrawn\n// canvas: unit=px w=250 h=326\n// layout: neato -n2\n") || strings.Contains(dot, `"n5"`) {
 		t.Errorf("unrouted-node DOT:\n%s", dot)
 	}
 	// A tree has no clusters to box round members: the parent itself is left
-	// to neato when nothing routes to it.
+	// undrawn when nothing routes to it, its children drawn with no edge to it.
 	rendering.Roots[0].Children = rendering.Roots[0].Children[:4]
 	rendering.Kind = KindTree
 	dot, err = rendering.DOT()
@@ -834,11 +842,156 @@ digraph "Routed::view" {
 		t.Fatalf("DOT: %v", err)
 	}
 	checkDOTSyntax(t, dot)
-	if !strings.Contains(dot, "// layout: neato\n") || strings.Contains(dot, "bb=") || !strings.Contains(dot, `"n0" [label=<<b>SendAck</b><br/><font point-size="10"><i>«action def»</i></font>>];`) {
+	if !strings.Contains(dot, "// layout: neato -n2\n") || strings.Contains(dot, "bb=") || strings.Contains(dot, `"n0"`) || !strings.Contains(dot, `"n1" -> "n2" [pos=`) {
 		t.Errorf("tree DOT:\n%s", dot)
 	}
 }
 
+// A drawing some Layout positions leaves the nodes none does undrawn, with the
+// edges at them, and says so; asked for the strip, it sets them in rows below
+// everything placed — canvas, boxes and routes — a gap clear of it and of one
+// another, an unplaced cluster round its own members, a tree's nodes each on
+// their own; a drawing nothing positions is laid out by `dot` as ever.
+func TestDOTSettlesUnplacedNodes(t *testing.T) {
+	rendering := func() *Rendering {
+		return &Rendering{
+			View:   "V",
+			Kind:   KindInterconnection,
+			Canvas: &Canvas{Unit: "px", Width: 300, Height: 100, HasSize: true},
+			Roots: []*Node{
+				{ID: "placed", Kind: "part", Name: "pump", Geometry: &Geometry{X: 10, Y: 10, Width: 100, Height: 40, HasSize: true}},
+				{ID: "low", Kind: "part", Name: "tank", Geometry: &Geometry{X: 150, Y: 120, Width: 60, Height: 30, HasSize: true}},
+				{ID: "loose", Kind: "part", Name: "spare"},
+				{ID: "wide", Kind: "part def", Name: "A rather long definition name"},
+				{ID: "group", Kind: "part def", Name: "Group", Children: []*Node{
+					{ID: "g1", Kind: "part", Name: "g1"},
+					{ID: "g2", Kind: "part", Name: "g2"},
+				}},
+			},
+			Edges: []Edge{
+				{From: "placed", To: "low", Kind: EdgeConnection, Route: []Point{{X: 60, Y: 50}, {X: 60, Y: 170}, {X: 150, Y: 170}}},
+				{From: "placed", To: "loose", Kind: EdgeConnection},
+				{From: "loose", To: "g1", Kind: EdgeFlow},
+			},
+		}
+	}
+	dot, err := rendering().DOT()
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	checkDOTSyntax(t, dot)
+	if !strings.Contains(dot, "// not represented: 5 node(s) without a position, left undrawn, and 2 edge(s) at them\n// canvas: unit=px w=300 h=100\n// layout: neato -n2\n") {
+		t.Errorf("omitting DOT header:\n%s", dot)
+	}
+	for _, id := range []string{"loose", "wide", "group", "g1", "g2"} {
+		if strings.Contains(dot, dotQuote(id)) {
+			t.Errorf("omitting DOT draws unplaced %s:\n%s", id, dot)
+		}
+	}
+	if !strings.Contains(dot, `"placed" -> "low" [arrowhead=none, penwidth=3, pos=`) || strings.Count(dot, " -> ") != 1 {
+		t.Errorf("omitting DOT edges:\n%s", dot)
+	}
+	// The strip: the canvas is 300 wide but tank reaches to y=170 with its route,
+	// so the strip starts at y=194 and rows wrap at x=300.
+	dot, err = rendering().DOTWith(Options{Unplaced: UnplacedStrip})
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	checkDOTSyntax(t, dot)
+	if !strings.Contains(dot, "// not represented: 5 node(s) without a position, drawn in a strip below the drawing\n// canvas: unit=px w=300 h=100\n// layout: neato -n2\n") {
+		t.Errorf("strip DOT header:\n%s", dot)
+	}
+	for _, want := range []string{
+		// spare: 63x37 from (0, 194), so its centre is (31.5, 212.5), y flipped
+		// against the 100-high canvas; the long name, 284 wide, would overrun 300
+		// beside it, so it heads the next row, 24 below.
+		`"loose" [style="rounded,filled", label=<<b>spare</b><br/><font point-size="10"><i>«part»</i></font>>, pos="31.5,-112.5!", pin=true, width=0.875, height=0.5138888888888888];`,
+		`"wide" [label=<<b>A rather long definition name</b><br/><font point-size="10"><i>«part def»</i></font>>, pos="142,-173.5!", pin=true, width=3.9444444444444446, height=0.5138888888888888];`,
+		// Group heads the third row at y=316: its title, then g1 and g2 side by
+		// side, a margin of 8 in from its box.
+		"    bb=\"0,-298,148,-216\";\n",
+		`"g1" [style="rounded,filled", label=<<b>g1</b><br/><font point-size="10"><i>«part»</i></font>>, pos="35,-271.5!", pin=true, width=0.75, height=0.5138888888888888];`,
+		`"g2" [style="rounded,filled", label=<<b>g2</b><br/><font point-size="10"><i>«part»</i></font>>, pos="113,-271.5!", pin=true, width=0.75, height=0.5138888888888888];`,
+		`"placed" -> "loose" [arrowhead=none, penwidth=3];`,
+		`"loose" -> "g1" [style=dashed];`,
+	} {
+		if !strings.Contains(dot, want) {
+			t.Errorf("strip DOT lacks %q:\n%s", want, dot)
+		}
+	}
+	assertStripBelow(t, rendering(), 170)
+	// A tree sets each unplaced node on its own, the containment edges drawn to them.
+	tree := rendering()
+	tree.Kind = KindTree
+	dot, err = tree.DOTWith(Options{Unplaced: UnplacedStrip})
+	if err != nil {
+		t.Fatalf("DOT: %v", err)
+	}
+	checkDOTSyntax(t, dot)
+	if strings.Contains(dot, "bb=") || !strings.Contains(dot, `"group" -> "g1" [arrowhead=none];`) ||
+		!strings.Contains(dot, `"group" [label=<<b>Group</b><br/><font point-size="10"><i>«part def»</i></font>>, pos="38,-234.5!", pin=true, width=1.0555555555555556, height=0.5138888888888888];`) ||
+		!strings.Contains(dot, `"g2" [style="rounded,filled", label=<<b>g2</b><br/><font point-size="10"><i>«part»</i></font>>, pos="205,-234.5!", pin=true, width=0.75, height=0.5138888888888888];`) {
+		t.Errorf("tree strip DOT:\n%s", dot)
+	}
+	assertStripBelow(t, tree, 170)
+	// Nothing positioned: every node drawn, laid out by dot, whatever is asked.
+	for _, unplaced := range []Unplaced{"", UnplacedOmit, UnplacedStrip} {
+		plain := rendering()
+		plain.Canvas = nil
+		for _, root := range plain.Roots {
+			root.Geometry = nil
+		}
+		plain.Edges[0].Route = nil
+		dot, err = plain.DOTWith(Options{Unplaced: unplaced})
+		if err != nil {
+			t.Fatalf("%q: DOT: %v", unplaced, err)
+		}
+		if !strings.Contains(dot, "// kind: interconnection\n// layout: dot\n") || strings.Contains(dot, "pos=") || strings.Count(dot, " -> ") != 3 {
+			t.Errorf("%q: unpositioned DOT:\n%s", unplaced, dot)
+		}
+	}
+	// A placement no name has is refused, naming the ones there are.
+	if _, err := rendering().DOTWith(Options{Unplaced: "pile"}); err == nil || !errors.Is(err, ErrUnknownUnplaced) || err.Error() != `unknown placement "pile" of unplaced nodes; the placements are omit, strip` {
+		t.Errorf("unknown placement: %v", err)
+	}
+}
+
+// assertStripBelow checks every node the strip places sits below everything
+// the Layouts place — the canvas and every stated box and route end at floor —
+// and that no two strip boxes overlap.
+func assertStripBelow(t *testing.T, r *Rendering, floor float64) {
+	t.Helper()
+	w := newDOTWriter(r, Options{})
+	stated := map[string]nodeBox{}
+	for id, box := range w.boxes {
+		stated[id] = box
+	}
+	w.stripUnplaced(r.Roots, r.Edges)
+	var strip []nodeBox
+	for id, box := range w.boxes {
+		if _, ok := stated[id]; ok {
+			continue
+		}
+		if box.low.Y < floor+dotStripGap {
+			t.Errorf("strip box %s at y=%v is not below the drawing's %v", id, box.low.Y, floor)
+		}
+		strip = append(strip, box)
+	}
+	if len(strip) == 0 {
+		t.Fatal("the strip placed nothing")
+	}
+	for i, a := range strip {
+		for _, b := range strip[i+1:] {
+			if a.encloses(b) || b.encloses(a) {
+				continue // a cluster round its members
+			}
+			if a.low.X < b.high.X && b.low.X < a.high.X && a.low.Y < b.high.Y && b.low.Y < a.high.Y {
+				t.Errorf("strip boxes overlap: %+v and %+v", a, b)
+			}
+		}
+	}
+}
+
 // checkDOTSyntax checks dot is well-formed without Graphviz: braces balance,
 // no ID is bare, edges join declared nodes, lhead/ltail name declared clusters.
 func checkDOTSyntax(t *testing.T, dot string) {
@@ -940,7 +1093,7 @@ func checkDOTAttributes(t *testing.T, tokens []dotToken, i int, dot string, clip
 			t.Fatalf("attribute list is not name=value at token %d (%q):\n%s", i, tokens[i].text, dot)
 		}
 		name, value := tokens[i].text, tokens[i+2]
-		if (name == "label" || name == "lhead" || name == "ltail" || name == "pos" || name == "bb" || name == "comment") && !value.quoted {
+		if (name == "label" || name == "xlabel" || name == "lhead" || name == "ltail" || name == "pos" || name == "bb" || name == "comment") && !value.quoted {
 			t.Fatalf("attribute %s has a bare value %q:\n%s", name, value.text, dot)
 		}
 		if value.html {
diff --git a/internal/ir/view/form.go b/internal/ir/view/form.go
index 68fdb4163..a6d78267f 100644
--- a/internal/ir/view/form.go
+++ b/internal/ir/view/form.go
@@ -136,8 +136,9 @@ func (e *WrongFormError) Unwrap() error { return ErrWrongForm }
 
 // Options are what a rendering is written with beside its form. Each form
 // takes the ones that apply to it: the text form its Width, the Mermaid form
-// its Direction, the DOT and PlantUML forms their Direction and Palette. A form
-// ignores the rest, the Mermaid form saying so of a Palette in a comment.
+// its Direction, the DOT and PlantUML forms their Direction and Palette, the
+// DOT form its Unplaced. A form ignores the rest, the Mermaid form saying so
+// of a Palette in a comment.
 type Options struct {
 	// Direction is the flow direction a graph-shaped form is drawn in; empty
 	// leaves each kind's default.
@@ -145,6 +146,9 @@ type Options struct {
 	// Palette is the palette the DOT and PlantUML forms fill nodes from, by
 	// keyword family; empty draws in black and white.
 	Palette Palette
+	// Unplaced is what the DOT form does with the nodes a positioned drawing
+	// leaves unplaced; empty leaves them undrawn, as UnplacedOmit does.
+	Unplaced Unplaced
 	// Width is the width the text form is written to fit; WidthUnbounded
 	// writes every column as wide as its widest cell.
 	Width int
diff --git a/internal/ir/view/geometry.go b/internal/ir/view/geometry.go
index d3ff9059f..3e8938de2 100644
--- a/internal/ir/view/geometry.go
+++ b/internal/ir/view/geometry.go
@@ -78,6 +78,13 @@ func (r *Renderer) declaredRouteOf(view, elem *symbols.Symbol, decl ast.Node, ou
 	return r.routeOf(view, edge, out)
 }
 
+// declaredNameSynthesized reports whether a migration made up the name of the
+// element decl declares under elem, as declaredRouteOf finds that element.
+func (r *Renderer) declaredNameSynthesized(elem *symbols.Symbol, decl ast.Node) bool {
+	sym, ok := r.model.SymbolDeclaring(documentScope(elem), decl)
+	return ok && r.model.NameSynthesized(sym)
+}
+
 // declaredGeometryOf is the Geometry of the node lowered from decl, a state,
 // region or action node declared under elem; nil when decl declares no element.
 func (r *Renderer) declaredGeometryOf(view, elem *symbols.Symbol, decl ast.Node, out *Rendering) *Geometry {
diff --git a/internal/ir/view/interconnection.go b/internal/ir/view/interconnection.go
index 83eba9c33..b289d5090 100644
--- a/internal/ir/view/interconnection.go
+++ b/internal/ir/view/interconnection.go
@@ -60,8 +60,8 @@ func (w *featureWalk) featureNode(sym *symbols.Symbol, seen map[*symbols.Symbol]
 	if !qualified {
 		name = localName(sym)
 	}
-	node := &Node{ID: w.ids.take(), Kind: declKind(sym), Name: name, Type: declType(sym), Origin: symbolOrigin(sym),
-		Geometry: r.geometryOf(w.view, sym, w.out)}
+	node := &Node{ID: w.ids.take(), Kind: declKind(sym), Name: name, NameSynthesized: r.model.NameSynthesized(sym),
+		Type: declType(sym), Typings: r.declTypings(sym), Origin: symbolOrigin(sym), Geometry: r.geometryOf(w.view, sym, w.out)}
 	if existing, ok := w.nodes[sym]; ok {
 		node.Detail = detailWith(node.Detail, "already shown as "+existing.ID)
 		return node
@@ -71,7 +71,7 @@ func (w *featureWalk) featureNode(sym *symbols.Symbol, seen map[*symbols.Symbol]
 		return node
 	}
 	seen[sym] = true
-	for _, member := range containedMembers(sym) {
+	for _, member := range r.containedMembers(sym) {
 		switch {
 		case r.drawsConnector(member):
 			w.connectors = append(w.connectors, member)
@@ -108,8 +108,8 @@ func (r *Renderer) connectionEdges(view, connector *symbols.Symbol, nodes map[*s
 	for i := 0; i < len(resolved); i++ {
 		for j := i + 1; j < len(resolved); j++ {
 			out.Edges = append(out.Edges, Edge{
-				From: resolved[i].ID, To: resolved[j].ID, Label: label, Kind: kind, Origin: symbolOrigin(connector),
-				Route: slices.Clone(route),
+				From: resolved[i].ID, To: resolved[j].ID, Label: label, Kind: kind,
+				Origin: symbolOrigin(connector), Route: slices.Clone(route),
 			})
 		}
 	}
@@ -197,11 +197,12 @@ func chainOperand(node ast.Node) ast.Node {
 
 // connectorLabel names a connection on an edge: the payload it carries, else its
 // own name, else the type it is declared with, else the keyword that declared it.
+// A name a migration made up counts as none, as for the unnamed source connector.
 func (r *Renderer) connectorLabel(connector *symbols.Symbol) string {
 	if payload := flowPayload(connector); payload != "" {
 		return "of " + notationName(payload)
 	}
-	if connector.Name != "" && !connector.EffectiveName() {
+	if connector.Name != "" && !connector.EffectiveName() && !r.model.NameSynthesized(connector) {
 		return localName(connector)
 	}
 	if declared := declType(connector); declared != "" {
diff --git a/internal/ir/view/label.go b/internal/ir/view/label.go
index aedd36990..11b41ffe3 100644
--- a/internal/ir/view/label.go
+++ b/internal/ir/view/label.go
@@ -7,13 +7,16 @@ import (
 )
 
 // labeller heads the nodes of one rendering the way a diagram names them: a
-// node by its name under the namespace every root shares, a type by its own name.
+// node by its name under the namespace every root shares, or under the drawn
+// owner that holds it, a type by its own name.
 type labeller struct {
-	context []string // the shared namespace's names, outermost first
+	context []string         // the shared namespace's names, outermost first
+	owned   map[*Node]string // a node's name relative to the nearest drawn owner
 }
 
-// labelsOf finds the namespace the named roots share: the longest run of
-// leading names common to their qualifiers.
+// labelsOf finds the namespace the named roots share — the longest run of
+// leading names common to their qualifiers — and, for every node whose
+// qualified name continues that of another drawn node, its name below that owner.
 func labelsOf(roots []*Node) labeller {
 	var context []string
 	found := false
@@ -36,11 +39,74 @@ func labelsOf(roots []*Node) labeller {
 		}
 		context = context[:n]
 	}
-	return labeller{context: context}
+	return labeller{context: context, owned: ownedNames(roots)}
 }
 
-// name is a node's name with the shared namespace left off the front.
+// ownedNames names each node relative to the nearest drawn owner its qualified
+// name continues: a drawn node, or the type of a drawn usage, whose members the
+// usage's box holds. A root's name is its qualified name; a child named with one
+// name is named under its parent, one named with a qualified name stands on its
+// own, as a nested view's exposed elements do.
+func ownedNames(roots []*Node) map[*Node]string {
+	drawn := map[string]bool{}
+	qualified := map[*Node][]string{} // the nodes named with a qualifier: the ones to shorten
+	var walk func(nodes []*Node, root bool, parent []string)
+	walk = func(nodes []*Node, root bool, parent []string) {
+		for _, node := range nodes {
+			var names []string
+			if node.Name != "" {
+				segments, ok := source.QualifiedNameSegments(node.Name)
+				switch {
+				case !ok:
+				case len(segments) > 1:
+					names, qualified[node] = segments, segments
+				case root:
+					names = segments
+				case parent != nil:
+					names = append(slices.Clone(parent), segments[0])
+				}
+			}
+			if names != nil {
+				drawn[source.QualifiedNameOf(names)] = true
+			}
+			for _, typ := range drawnTypes(node) {
+				drawn[typ] = true
+			}
+			walk(node.Children, false, names)
+		}
+	}
+	walk(roots, true, nil)
+	owned := map[*Node]string{}
+	for node, names := range qualified {
+		for n := len(names) - 1; n > 0; n-- {
+			if drawn[source.QualifiedNameOf(names[:n])] {
+				owned[node] = source.QualifiedNameOf(names[n:])
+				break
+			}
+		}
+	}
+	return owned
+}
+
+// drawnTypes are the qualified names of the types a node's box draws the members
+// of: the elements its typings resolved to, else the typings as written.
+func drawnTypes(node *Node) []string {
+	if len(node.Typings) > 0 {
+		return node.Typings
+	}
+	var types []string
+	for _, typ := range source.ReferenceQualifiedNames(node.Type) {
+		types = append(types, source.QualifiedNameOf(typ))
+	}
+	return types
+}
+
+// name is a node's name below its nearest drawn owner, or else with the
+// shared namespace left off the front.
 func (l labeller) name(node *Node) string {
+	if name, ok := l.owned[node]; ok {
+		return name
+	}
 	if len(l.context) == 0 {
 		return node.Name
 	}
@@ -51,24 +117,42 @@ func (l labeller) name(node *Node) string {
 	return source.QualifiedNameOf(names[len(l.context):])
 }
 
+// shown is the name a diagram shows for a node: its Name, unless a migration
+// made that up, in which case the node is drawn as its source drew it, unnamed.
+func shown(node *Node) string {
+	if node.NameSynthesized {
+		return ""
+	}
+	return node.Name
+}
+
 // head is the first line of a node's diagram label: its name, followed by
 // " : Type" for a typed usage, each type by the name it ends in. A node with no
-// name leads with its kind instead.
+// shown name leads with " : Type" alone when typed, else with its kind.
 func (l labeller) head(node *Node) string {
-	if node.Name == "" {
+	switch name, typ := shown(node), node.Type; {
+	case name == "" && typ == "":
 		return node.Kind
-	}
-	if node.Type == "" {
+	case name == "":
+		return ": " + source.ReferenceEndNames(typ)
+	case typ == "":
 		return l.name(node)
+	default:
+		return l.name(node) + " : " + source.ReferenceEndNames(typ)
 	}
-	return l.name(node) + " : " + source.ReferenceEndNames(node.Type)
+}
+
+// keyworded reports whether a node's label has a keyword line, the kind in
+// guillemets after the head: every node whose head is not the kind itself.
+func keyworded(node *Node) bool {
+	return shown(node) != "" || node.Type != ""
 }
 
 // lines is a node's diagram label in the graphical notation's order: the
-// head, the kind in guillemets when the head is a name, then the notes.
+// head, the keyword line when the node has one, then the notes.
 func (l labeller) lines(node *Node) []string {
 	lines := []string{l.head(node)}
-	if node.Name != "" {
+	if keyworded(node) {
 		lines = append(lines, "«"+node.Kind+"»")
 	}
 	if node.Detail != "" {
diff --git a/internal/ir/view/label_test.go b/internal/ir/view/label_test.go
index 7cd4025af..7c5cbbe55 100644
--- a/internal/ir/view/label_test.go
+++ b/internal/ir/view/label_test.go
@@ -19,7 +19,9 @@ func TestLabelLines(t *testing.T) {
 		{"untyped usage", &Node{Kind: "port", Name: "p"}, []string{"p", "«port»"}},
 		{"definition", &Node{Kind: "part def", Name: "Plant::Loop"}, []string{"Plant::Loop", "«part def»"}},
 		{"name-less", &Node{Kind: "connect"}, []string{"connect"}},
-		{"name-less typed", &Node{Kind: "part", Type: "Pump"}, []string{"part"}},
+		{"name-less typed", &Node{Kind: "part", Type: "Pump"}, []string{": Pump", "«part»"}},
+		{"synthesized name", &Node{Kind: "action", Name: "call", Type: "P::doTracking", NameSynthesized: true}, []string{": doTracking", "«action»"}},
+		{"synthesized name, untyped", &Node{Kind: "action", Name: "stamp2", NameSynthesized: true}, []string{"action"}},
 		{"name-less with note", &Node{Kind: "connect", Detail: "already shown"}, []string{"connect", "already shown"}},
 		{"notes", &Node{Kind: "part", Name: "sensor", Type: "Pump", Detail: "already shown as n1"},
 			[]string{"sensor : Pump", "«part»", "already shown as n1"}},
@@ -72,6 +74,111 @@ func TestLabelsHeadRootsUnderTheirSharedNamespace(t *testing.T) {
 	}
 }
 
+// A node whose qualified name continues that of another drawn node is headed
+// by its name below that owner — the nearest one drawn — whether the owner is
+// a root or a child named under its parent; a node whose owner is not drawn
+// keeps its name under the shared namespace, and a nested view's exposed
+// elements, named in full, are owners in their own right.
+func TestLabelsHeadMembersUnderTheirDrawnOwner(t *testing.T) {
+	roots := []*Node{
+		{Kind: "part def", Name: "TMT::Budget::'K-Mirror Offset'", Children: []*Node{
+			{Kind: "attribute", Name: "errorReq", Type: "ScalarValues::Real"},
+			{Kind: "part", Name: "stage", Children: []*Node{{Kind: "port", Name: "inlet"}}},
+		}},
+		{Kind: "attribute", Name: "TMT::Budget::'K-Mirror Offset'::errorReq", Type: "ScalarValues::Real"},
+		{Kind: "part", Name: "TMT::Budget::'K-Mirror Offset'::'interpolation Error'", Type: "TMT::Budget::'Interpolation Error'"},
+		{Kind: "port", Name: "TMT::Budget::'K-Mirror Offset'::stage::inlet"},
+		{Kind: "attribute", Name: "TMT::Budget::'Shear Plate'::errorCBE"},
+		{Kind: "attribute", Name: "TMT::Budget::'K-Mirror Offset'::'interpolation Error'::deep::errorMargin"},
+		{Kind: "view", Name: "TMT::Budget::Views::details", Children: []*Node{
+			{Kind: "part def", Name: "TMT::Budget::Lens"},
+			{Kind: "attribute", Name: "TMT::Budget::Lens::focal"},
+		}},
+	}
+	labels := labelsOf(roots)
+	want := []string{
+		"'K-Mirror Offset'",
+		"errorReq : Real",
+		"'interpolation Error' : 'Interpolation Error'",
+		"inlet",
+		"'Shear Plate'::errorCBE",
+		"deep::errorMargin",
+		"Views::details",
+	}
+	var got []string
+	for _, root := range roots {
+		got = append(got, labels.head(root))
+	}
+	if strings.Join(got, "\x00") != strings.Join(want, "\x00") {
+		t.Errorf("heads = %q, want %q", got, want)
+	}
+	for node, want := range map[*Node]string{
+		roots[0].Children[0]:             "errorReq : Real",
+		roots[0].Children[1].Children[0]: "inlet",
+		roots[6].Children[1]:             "focal",
+	} {
+		if got := labels.head(node); got != want {
+			t.Errorf("child %q headed %q, want %q", node.Name, got, want)
+		}
+	}
+	rendering := &Rendering{View: "V", Kind: KindTree, Roots: roots}
+	if text := rendering.Text(); !strings.Contains(text, "attribute TMT::Budget::'K-Mirror Offset'::errorReq : ScalarValues::Real\n") {
+		t.Errorf("the text form is headed by the diagram label:\n%s", text)
+	}
+}
+
+// A member of a drawn usage's type is headed by its name below that type, as
+// the usage's box holds it — an interconnection rendering exposes the parts and
+// ports of a part's type flat; a member of a type no drawn usage has keeps its
+// qualifier, and a type written without one names no owner.
+func TestLabelsHeadMembersUnderTheirDrawnOwnersType(t *testing.T) {
+	roots := []*Node{
+		{Kind: "part", Name: "TMT::Design::'Optical Bench'::sH", Type: "TMT::Design::'SH Assembly'::SH"},
+		{Kind: "part", Name: "TMT::Design::'SH Assembly'::SH::'SH Filter Wheel'", Type: "TMT::Design::Parts::'Rotational Filter Wheel'"},
+		{Kind: "port", Name: "TMT::Design::Parts::'Rotational Filter Wheel'::'bN sensor2'", Type: "~TMT::Design::Parts::'BN sensor'"},
+		{Kind: "port", Name: "TMT::Design::Parts::Shutter::digital3", Type: "Digital"},
+		{Kind: "part", Name: "TMT::Design::'Optical Bench'::pIT", Type: "PIT"},
+		{Kind: "part", Name: "TMT::Design::PIT::'PIT CCD'", Type: "CCD"},
+		// A type written by its bare name is drawn as the element it resolves to.
+		{Kind: "part", Name: "TMT::Design::'APS Physical'::'summit Installation'", Type: "'Summit Installation'",
+			Typings: []string{"TMT::Design::Physical::'Summit Installation'"}},
+		{Kind: "part", Name: "TMT::Design::Physical::'Summit Installation'::computer", Type: "Control"},
+	}
+	want := []string{
+		"'Optical Bench'::sH : SH",
+		"'SH Filter Wheel' : 'Rotational Filter Wheel'",
+		"'bN sensor2' : ~'BN sensor'",
+		"Parts::Shutter::digital3 : Digital",
+		"'Optical Bench'::pIT : PIT",
+		"PIT::'PIT CCD' : CCD",
+		"'APS Physical'::'summit Installation' : 'Summit Installation'",
+		"computer : Control",
+	}
+	labels := labelsOf(roots)
+	var got []string
+	for _, root := range roots {
+		got = append(got, labels.head(root))
+	}
+	if strings.Join(got, "\x00") != strings.Join(want, "\x00") {
+		t.Errorf("heads = %q, want %q", got, want)
+	}
+	// From a model: the usage's type is written by its imported bare name and
+	// resolves to the element whose member is exposed beside it.
+	rendering := render(t, "typings.sysml", "SpelledViews::siteView")
+	labels = labelsOf(rendering.Roots)
+	got = got[:0]
+	for _, root := range rendering.Roots {
+		got = append(got, labels.head(root))
+	}
+	want = []string{"Physical::'APS Physical'::'summit Installation' : 'Summit Installation'", "computer : Control"}
+	if strings.Join(got, "\x00") != strings.Join(want, "\x00") {
+		t.Errorf("heads = %q, want %q", got, want)
+	}
+	if text := rendering.Text(); !strings.Contains(text, "part Sites::'Summit Installation'::computer : Control") {
+		t.Errorf("the text form is headed by the diagram label:\n%s", text)
+	}
+}
+
 // The text form keeps the keyword leading, writes the type after a colon and
 // the notes in parentheses after it.
 func TestTextLabelShape(t *testing.T) {
diff --git a/internal/ir/view/place.go b/internal/ir/view/place.go
index 3692d2fd8..ad979710e 100644
--- a/internal/ir/view/place.go
+++ b/internal/ir/view/place.go
@@ -53,7 +53,7 @@ func (r *Renderer) draws(kind Kind, sym *symbols.Symbol) (node, edge bool) {
 	}
 	switch kind {
 	case KindTree:
-		return containedKind(sym), false
+		return r.contentKind(sym), false
 	case KindInterconnection:
 		return featureLike(sym), r.drawsConnector(sym)
 	case KindState:
diff --git a/internal/ir/view/plantuml.go b/internal/ir/view/plantuml.go
index 27044aa41..b1270b9ba 100644
--- a/internal/ir/view/plantuml.go
+++ b/internal/ir/view/plantuml.go
@@ -391,7 +391,7 @@ func (w *plantumlWriter) plantumlLabel(node *Node) string {
 	for _, line := range lines[1:] {
 		parts = append(parts, plantumlText(line))
 	}
-	if node.Name != "" {
+	if keyworded(node) {
 		parts[1] = fmt.Sprintf("<size:%d>//%s//</size>", plantumlKeywordFontSize, parts[1])
 	}
 	return strings.Join(parts, `\n`)
diff --git a/internal/ir/view/plantuml_test.go b/internal/ir/view/plantuml_test.go
index dece27240..691f8054c 100644
--- a/internal/ir/view/plantuml_test.go
+++ b/internal/ir/view/plantuml_test.go
@@ -184,7 +184,8 @@ func TestPlantUMLStateDiagram(t *testing.T) {
 
 // An action rendering takes the state grammar: control nodes are states with
 // their kind as stereotype, successions solid arrows and flows dashed and
-// labelled, every node and edge of the graph drawn.
+// labelled, every node and edge of the graph drawn. The `start` and `done` the
+// language names head as their kind, since those names are not the body's.
 func TestPlantUMLActionUsesStateGrammar(t *testing.T) {
 	puml, err := render(t, "action.sysml", "FlowViews::driveView").PlantUML()
 	if err != nil {
@@ -193,9 +194,9 @@ func TestPlantUMLActionUsesStateGrammar(t *testing.T) {
 	for _, want := range []string{
 		"\nhide empty description\n",
 		"state \"**Drive**\\n<size:10>//«action def»//</size>\" as n0 <<action def>> {\n",
-		"  state \"**start**\\n<size:10>//«initial»//</size>\" as n1 <<start>>\n",
+		"  state \"**initial**\" as n1 <<start>>\n",
 		"  state \"**split**\\n<size:10>//«fork»//</size>\" as n8 <<fork>>\n",
-		"  state \"**done**\\n<size:10>//«final»//</size>\" as n10 <<end>>\n",
+		"  state \"**final**\" as n10 <<end>>\n",
 		"  state \"**check**\\n<size:10>//«decision»//</size>\" as n12 <<choice>>\n",
 		"  state \"**monitor**\\n<size:10>//«action»//</size>\\nown flow\" as n3 <<action>> <<usage>> {\n",
 		"\nn2 -[dashed]-> n3 : torque to reading\n",
diff --git a/internal/ir/view/render_test.go b/internal/ir/view/render_test.go
index 90267d645..660ed5001 100644
--- a/internal/ir/view/render_test.go
+++ b/internal/ir/view/render_test.go
@@ -426,6 +426,20 @@ func TestDeclaredTypesAreSpelledAsWritten(t *testing.T) {
 			t.Errorf("Mermaid lacks %q:\n%s", want, mermaid)
 		}
 	}
+	// Beside the spelling, a node carries the qualified names its typings
+	// resolve to; a feature chain names no element and resolves to none.
+	typings := map[string][]string{
+		"plug":     {"Spelled::Link"},
+		"rail":     {"Spelled::'Frame *rail*'"},
+		"base":     {"Spelled::Mount", "Spelled::Cart"},
+		"root":     {"Spelled::Mount"},
+		"mirrored": nil,
+	}
+	for name, want := range typings {
+		if node := findNode(t, rendering.Roots, name); !slices.Equal(node.Typings, want) {
+			t.Errorf("node %s: typings %q, want %q", name, node.Typings, want)
+		}
+	}
 	// An anonymous connection or message is labeled by its type, spelled once.
 	if got := edgeLabels(render(t, "typings.sysml", "SpelledViews::rigConnections")); !got["Bolt, Weld"] {
 		t.Errorf("connection edge labels %v lack %q", slices.Sorted(maps.Keys(got)), "Bolt, Weld")
diff --git a/internal/ir/view/sequence.go b/internal/ir/view/sequence.go
index 24d59c794..ac769c7a5 100644
--- a/internal/ir/view/sequence.go
+++ b/internal/ir/view/sequence.go
@@ -29,7 +29,7 @@ func (r *Renderer) renderSequence(exposed []*symbols.Symbol, out *Rendering) {
 		case r.model.IsConnectorUsage(elem):
 			stated.addConnector(elem)
 		case occurrenceContainer(elem), lifelineLike(elem):
-			for _, participant := range lifelinesOf(elem) {
+			for _, participant := range r.lifelinesOf(elem) {
 				if lifelines[participant] != nil {
 					continue
 				}
@@ -37,8 +37,8 @@ func (r *Renderer) renderSequence(exposed []*symbols.Symbol, out *Rendering) {
 				if participant != elem {
 					name = localName(participant)
 				}
-				node := &Node{ID: ids.take(), Kind: declKind(participant), Name: name,
-					Type: declType(participant), Origin: symbolOrigin(participant)}
+				node := &Node{ID: ids.take(), Kind: declKind(participant), Name: name, NameSynthesized: r.model.NameSynthesized(participant),
+					Type: declType(participant), Typings: r.declTypings(participant), Origin: symbolOrigin(participant)}
 				out.Roots = append(out.Roots, node)
 				lifelines[participant] = node
 			}
@@ -62,10 +62,10 @@ func (r *Renderer) renderSequence(exposed []*symbols.Symbol, out *Rendering) {
 // an interaction declares in its body, else the element itself when it declares
 // none. The container is not a lifeline of its own interaction, and neither is
 // behavior it performs, which a sequence rendering shows as messages instead.
-func lifelinesOf(elem *symbols.Symbol) []*symbols.Symbol {
+func (r *Renderer) lifelinesOf(elem *symbols.Symbol) []*symbols.Symbol {
 	if occurrenceContainer(elem) {
 		var participants []*symbols.Symbol
-		for _, member := range containedMembers(elem) {
+		for _, member := range r.containedMembers(elem) {
 			if lifelineLike(member) && !behaviorLike(member) {
 				participants = append(participants, member)
 			}
@@ -137,7 +137,7 @@ func (r *Renderer) collectInteractions(sym *symbols.Symbol, into *interactions,
 	}
 	visited[sym] = true
 	r.addSuccessionEdges(sym, into)
-	for _, member := range containedMembers(sym) {
+	for _, member := range r.containedMembers(sym) {
 		switch {
 		case isFlowUsage(member):
 			into.addFlow(member)
@@ -164,7 +164,7 @@ func (r *Renderer) statesFlow(sym *symbols.Symbol, depth int) bool {
 	if sym == nil || depth >= maxTreeDepth {
 		return false
 	}
-	for _, member := range containedMembers(sym) {
+	for _, member := range r.containedMembers(sym) {
 		if isFlowUsage(member) || r.statesFlow(member, depth+1) {
 			return true
 		}
@@ -218,7 +218,7 @@ func (r *Renderer) edgeEnd(owner *symbols.Symbol, name *ast.QualifiedName, membe
 		}
 		return nil
 	}
-	for _, candidate := range containedMembers(owner) {
+	for _, candidate := range r.containedMembers(owner) {
 		if member != nil && candidate.Decl == member {
 			return candidate
 		}
diff --git a/internal/ir/view/table.go b/internal/ir/view/table.go
index 921e94b70..2d6c333f5 100644
--- a/internal/ir/view/table.go
+++ b/internal/ir/view/table.go
@@ -47,7 +47,7 @@ func (r *Renderer) memberRowsOf(sym *symbols.Symbol, name string, seen map[*symb
 		return
 	}
 	seen[sym] = true
-	for _, member := range containedMembers(sym) {
+	for _, member := range r.containedMembers(sym) {
 		r.memberRows(member, name, seen, depth+1, out)
 	}
 }
diff --git a/internal/ir/view/testdata/action.dot.golden b/internal/ir/view/testdata/action.dot.golden
index 38d5139b0..9d71e4d28 100644
--- a/internal/ir/view/testdata/action.dot.golden
+++ b/internal/ir/view/testdata/action.dot.golden
@@ -11,20 +11,20 @@ digraph "FlowViews::driveView" {
     color=black;
     penwidth=0.5;
     "n0" [shape=point, style=invis, width=0, height=0, label=""];
-    "n1" [shape=circle, label=<<b>start</b><br/><font point-size="10"><i>«initial»</i></font>>];
+    "n1" [shape=circle, fillcolor=black, label="", width=0.2];
     "n2" [style="rounded,filled", label=<<b>provide : Provide</b><br/><font point-size="10"><i>«action»</i></font>>];
     subgraph "cluster_n3" {
       label=<<b>monitor</b><br/><font point-size="10"><i>«action»</i></font><br/>own flow>;
       color=black;
       penwidth=0.5;
       "n3" [shape=point, style=invis, width=0, height=0, label=""];
-      "n5" [shape=circle, label=<<b>begin</b><br/><font point-size="10"><i>«initial»</i></font>>];
+      "n5" [shape=circle, fillcolor=black, label="", width=0.2];
       "n6" [style="rounded,filled", label=<<b>record</b><br/><font point-size="10"><i>«action»</i></font>>];
     }
     "n7" [style="rounded,filled", label=<<b>tally</b><br/><font point-size="10"><i>«action»</i></font>>];
     "n8" [label=<<b>split</b><br/><font point-size="10"><i>«fork»</i></font>>];
     "n9" [label=<<b>sync</b><br/><font point-size="10"><i>«join»</i></font>>];
-    "n10" [shape=doublecircle, label=<<b>done</b><br/><font point-size="10"><i>«final»</i></font>>];
+    "n10" [shape=doublecircle, fillcolor=black, label="", width=0.2];
     "n11" [style="rounded,filled", label=<<b>park</b><br/><font point-size="10"><i>«action»</i></font>>];
     "n12" [label=<<b>check</b><br/><font point-size="10"><i>«decision»</i></font>>];
   }
diff --git a/internal/ir/view/testdata/action.mermaid.golden b/internal/ir/view/testdata/action.mermaid.golden
index c0283c270..f0c59e414 100644
--- a/internal/ir/view/testdata/action.mermaid.golden
+++ b/internal/ir/view/testdata/action.mermaid.golden
@@ -8,17 +8,17 @@ config:
 flowchart TD
   subgraph n0 ["Drive<br>«action def»"]
     direction TD
-    n1["start<br>«initial»"]
+    n1["initial"]
     n2["provide : Provide<br>«action»"]
     subgraph n3 ["monitor<br>«action»<br>own flow"]
       direction TD
-      n5["begin<br>«initial»"]
+      n5["initial"]
       n6["record<br>«action»"]
     end
     n7["tally<br>«action»"]
     n8["split<br>«fork»"]
     n9["sync<br>«join»"]
-    n10["done<br>«final»"]
+    n10["final"]
     n11["park<br>«action»"]
     n12["check<br>«decision»"]
   end
diff --git a/internal/ir/view/testdata/action.plantuml.golden b/internal/ir/view/testdata/action.plantuml.golden
index b5caecc99..df897aea1 100644
--- a/internal/ir/view/testdata/action.plantuml.golden
+++ b/internal/ir/view/testdata/action.plantuml.golden
@@ -42,16 +42,16 @@ skinparam wrapWidth 300
 hide stereotype
 hide empty description
 state "**Drive**\n<size:10>//«action def»//</size>" as n0 <<action def>> {
-  state "**start**\n<size:10>//«initial»//</size>" as n1 <<start>>
+  state "**initial**" as n1 <<start>>
   state "**provide : Provide**\n<size:10>//«action»//</size>" as n2 <<action>> <<usage>>
   state "**monitor**\n<size:10>//«action»//</size>\nown flow" as n3 <<action>> <<usage>> {
-    state "**begin**\n<size:10>//«initial»//</size>" as n5 <<start>>
+    state "**initial**" as n5 <<start>>
     state "**record**\n<size:10>//«action»//</size>" as n6 <<action>> <<usage>>
   }
   state "**tally**\n<size:10>//«action»//</size>" as n7 <<action>> <<usage>>
   state "**split**\n<size:10>//«fork»//</size>" as n8 <<fork>>
   state "**sync**\n<size:10>//«join»//</size>" as n9 <<join>>
-  state "**done**\n<size:10>//«final»//</size>" as n10 <<end>>
+  state "**final**" as n10 <<end>>
   state "**park**\n<size:10>//«action»//</size>" as n11 <<action>> <<usage>>
   state "**check**\n<size:10>//«decision»//</size>" as n12 <<choice>>
 }
diff --git a/internal/ir/view/testdata/bookkeeping.sysml b/internal/ir/view/testdata/bookkeeping.sysml
new file mode 100644
index 000000000..bfd8aef34
--- /dev/null
+++ b/internal/ir/view/testdata/bookkeeping.sysml
@@ -0,0 +1,38 @@
+package Budget {
+	private import DiagramLayout::*;
+	private import Views::*;
+
+	metadata def Approved {
+		attribute by : ScalarValues::String;
+	}
+
+	part def Mirror {
+		attribute errorReq : ScalarValues::Real;
+		attribute errorCBE : ScalarValues::Real;
+		// A user annotation is model content the tree shows.
+		metadata Approved about errorCBE { by = "review"; }
+		// Layout stated inline is about a picture, not the part.
+		@Layout { x = 21; y = 56; width = 328; height = 108; }
+		metadata Layout about errorReq { x = 24; y = 108; width = 322; height = 14; }
+		metadata placed : Layout about errorCBE { x = 24; y = 122; width = 322; height = 14; }
+
+		view details {
+			expose errorReq;
+			@Canvas { unit = "px"; width = 1006; height = 570; }
+			metadata Layout about errorReq { x = 1; y = 2; }
+			render asTreeDiagram;
+		}
+	}
+
+	// A rendering usage declared outside a view is an ordinary member.
+	rendering asTree : GraphicalRendering;
+}
+
+package BudgetViews {
+	private import Views::*;
+
+	view budgetView {
+		expose Budget;
+		render asTreeDiagram;
+	}
+}
diff --git a/internal/ir/view/testdata/layout.dot.golden b/internal/ir/view/testdata/layout.dot.golden
index 313d1c7b0..70746f66c 100644
--- a/internal/ir/view/testdata/layout.dot.golden
+++ b/internal/ir/view/testdata/layout.dot.golden
@@ -16,7 +16,7 @@ digraph "PlantViews::placedView" {
     bb="292,692,628,768";
     "n0" [shape=point, style=invis, width=0, height=0, label="", pos="460,730!", pin=true];
     "n1" [style="rounded,filled", label=<<b>pump : Pump</b><br/><font point-size="10"><i>«part»</i></font>>, pos="359,741.5!", pin=true, width=1.6388888888888888, height=0.5138888888888888, comment="collapsed"];
-    "n2" [style="rounded,filled", label=<<b>tank : Tank</b><br/><font point-size="10"><i>«part»</i></font>>, pos="560,730!", pin=true, width=1.6666666666666667, height=0.8333333333333334, fixedsize=true];
+    "n2" [style="rounded,filled", label=<<b>tank : Tank</b><br/><font point-size="10"><i>«part»</i></font>>, margin=0, pos="560,730!", pin=true, width=1.6666666666666667, height=0.8333333333333334, fixedsize=true];
   }
   "n1" -> "n2" [label="supply", arrowhead=none, penwidth=3, pos="400,730 400,730 450,680 450,680 450,680 500,730 500,730"];
 }
diff --git a/internal/ir/view/testdata/synthesized.sysml b/internal/ir/view/testdata/synthesized.sysml
new file mode 100644
index 000000000..0da4c7dbd
--- /dev/null
+++ b/internal/ir/view/testdata/synthesized.sysml
@@ -0,0 +1,69 @@
+// A migrated model, as the SysML v1 migrator writes it: elements its source
+// left unnamed carry names the migration made up, listed by one
+// MigrationMetadata::SynthesizedName usage per body.
+package Migrated {
+	private import ScalarValues::*;
+
+	action def doTracking;
+
+	action def Track {
+		in target : Real;
+		succession 'start to call' first start then call;
+		action call : doTracking;
+		succession 'call to fork' first call then 'fork';
+		fork 'fork';
+		succession 'fork to log' first 'fork' then log;
+		action log;
+		succession 'fork to final' first 'fork' then final;
+		succession finish first log then final;
+		action final terminate;
+		metadata MigrationMetadata::SynthesizedName about 'start to call', 'call to fork', 'fork', 'fork to log', 'fork to final', final;
+	}
+
+	item def Go;
+	item def Stop;
+
+	state def Modes {
+		entry; then Idle;
+		state Idle;
+		state Running;
+		transition 'Idle accept Go then Running' first Idle accept Go then Running;
+		transition halt first Running accept Stop then Idle;
+		metadata MigrationMetadata::SynthesizedName about 'Idle accept Go then Running';
+	}
+
+	part def Engine;
+	part def Wheel;
+
+	part def Vehicle {
+		part engine : Engine;
+		part 'wheel' : Wheel;
+		connection 'engine to wheel' connect engine to 'wheel';
+		connection drive connect engine to 'wheel';
+		metadata MigrationMetadata::SynthesizedName about 'engine to wheel', 'wheel';
+	}
+}
+
+package MigratedViews {
+	private import Views::*;
+	private import StandardViewDefinitions::*;
+
+	view trackView : ActionFlowView {
+		expose Migrated::Track;
+		render asInterconnectionDiagram;
+	}
+
+	view modesView : StateTransitionView {
+		expose Migrated::Modes;
+	}
+
+	view vehicleView {
+		expose Migrated::Vehicle;
+		render asInterconnectionDiagram;
+	}
+
+	view treeView {
+		expose Migrated;
+		render asTreeDiagram;
+	}
+}
diff --git a/internal/ir/view/testdata/typed-action.mermaid.golden b/internal/ir/view/testdata/typed-action.mermaid.golden
index e0218503a..b514be3f4 100644
--- a/internal/ir/view/testdata/typed-action.mermaid.golden
+++ b/internal/ir/view/testdata/typed-action.mermaid.golden
@@ -8,9 +8,9 @@ config:
 flowchart TD
   subgraph n0 ["run : Cycle<br>«action»"]
     direction TD
-    n1["start<br>«initial»"]
+    n1["initial"]
     n2["warm : Warm<br>«action»"]
-    n3["done<br>«final»"]
+    n3["final"]
   end
   n1 --> n2
   n2 --> n3
diff --git a/internal/ir/view/testdata/typed-action.plantuml.golden b/internal/ir/view/testdata/typed-action.plantuml.golden
index 1943942d9..2246ed88f 100644
--- a/internal/ir/view/testdata/typed-action.plantuml.golden
+++ b/internal/ir/view/testdata/typed-action.plantuml.golden
@@ -42,9 +42,9 @@ skinparam wrapWidth 300
 hide stereotype
 hide empty description
 state "**run : Cycle**\n<size:10>//«action»//</size>" as n0 <<action>> <<usage>> {
-  state "**start**\n<size:10>//«initial»//</size>" as n1 <<start>>
+  state "**initial**" as n1 <<start>>
   state "**warm : Warm**\n<size:10>//«action»//</size>" as n2 <<action>> <<usage>>
-  state "**done**\n<size:10>//«final»//</size>" as n3 <<end>>
+  state "**final**" as n3 <<end>>
 }
 n1 --> n2
 n2 --> n3
diff --git a/internal/ir/view/testdata/typings.sysml b/internal/ir/view/testdata/typings.sysml
index 57a812b89..d229be879 100644
--- a/internal/ir/view/testdata/typings.sysml
+++ b/internal/ir/view/testdata/typings.sysml
@@ -36,6 +36,22 @@ package Spelled {
 	}
 }
 
+package Sites {
+	part def Control;
+
+	part def 'Summit Installation' {
+		part computer : Control;
+	}
+}
+
+package Physical {
+	private import Sites::*;
+
+	part def 'APS Physical' {
+		part 'summit Installation' : 'Summit Installation';
+	}
+}
+
 package SpelledViews {
 	private import Views::*;
 	private import StandardViewDefinitions::*;
@@ -52,4 +68,10 @@ package SpelledViews {
 	view exchangeView : SequenceView {
 		expose Spelled::Exchange;
 	}
+
+	view siteView {
+		expose Physical::'APS Physical'::'summit Installation';
+		expose Sites::'Summit Installation'::computer;
+		render asInterconnectionDiagram;
+	}
 }
diff --git a/internal/ir/view/tree.go b/internal/ir/view/tree.go
index 850ac417f..572f78045 100644
--- a/internal/ir/view/tree.go
+++ b/internal/ir/view/tree.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"sort"
 
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/semantics"
 	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
 )
 
@@ -37,8 +38,8 @@ func (r *Renderer) nestedViewNodes(view *symbols.Symbol, ids *nodeIDs, rendered
 			continue
 		}
 		rendered[sub] = true
-		node := &Node{ID: ids.take(), Kind: declKind(sub), Name: r.notationName(sub), Type: declType(sub), Origin: symbolOrigin(sub),
-			Geometry: r.geometryOf(view, sub, out)}
+		node := &Node{ID: ids.take(), Kind: declKind(sub), Name: r.notationName(sub), NameSynthesized: r.model.NameSynthesized(sub),
+			Type: declType(sub), Typings: r.declTypings(sub), Origin: symbolOrigin(sub), Geometry: r.geometryOf(view, sub, out)}
 		exposed, err := r.model.ExposedElements(sub)
 		if err == nil {
 			for _, elem := range exposed {
@@ -63,20 +64,20 @@ func (r *Renderer) treeNode(view, sym *symbols.Symbol, ids *nodeIDs, seen map[*s
 	if !qualified {
 		name = localName(sym)
 	}
-	node := &Node{ID: ids.take(), Kind: declKind(sym), Name: name, Type: declType(sym), Origin: symbolOrigin(sym),
-		Geometry: r.geometryOf(view, sym, out)}
+	node := &Node{ID: ids.take(), Kind: declKind(sym), Name: name, NameSynthesized: r.model.NameSynthesized(sym),
+		Type: declType(sym), Typings: r.declTypings(sym), Origin: symbolOrigin(sym), Geometry: r.geometryOf(view, sym, out)}
 	if seen[sym] {
 		node.Detail = detailWith(node.Detail, "already shown")
 		return node
 	}
 	if depth >= maxTreeDepth {
-		if len(containedMembers(sym)) > 0 {
+		if len(r.containedMembers(sym)) > 0 {
 			node.Detail = detailWith(node.Detail, fmt.Sprintf("nested deeper than %d levels; not shown", maxTreeDepth))
 		}
 		return node
 	}
 	seen[sym] = true
-	for _, member := range containedMembers(sym) {
+	for _, member := range r.containedMembers(sym) {
 		node.Children = append(node.Children, r.treeNode(view, member, ids, seen, depth+1, false, out))
 	}
 	return node
@@ -86,7 +87,7 @@ func (r *Renderer) treeNode(view, sym *symbols.Symbol, ids *nodeIDs, seen map[*s
 // declaration order: the elements a containment tree shows beneath it. A
 // reference member is anonymous, so the two member lists a scope keeps are
 // merged by source position rather than concatenated.
-func containedMembers(sym *symbols.Symbol) []*symbols.Symbol {
+func (r *Renderer) containedMembers(sym *symbols.Symbol) []*symbols.Symbol {
 	if sym == nil || sym.Scope == nil {
 		return nil
 	}
@@ -94,7 +95,7 @@ func containedMembers(sym *symbols.Symbol) []*symbols.Symbol {
 	seen := map[*symbols.Symbol]bool{}
 	for _, list := range [][]*symbols.Symbol{sym.Scope.Members(), sym.Scope.AnonymousMembers()} {
 		for _, member := range list {
-			if member == sym || seen[member] || !containedKind(member) {
+			if member == sym || seen[member] || !r.contentKind(member) {
 				continue
 			}
 			seen[member] = true
@@ -105,6 +106,22 @@ func containedMembers(sym *symbols.Symbol) []*symbols.Symbol {
 	return out
 }
 
+// contentKind reports whether a member is model content a rendering shows, as
+// against what only describes a picture of it or its migration: a view's `render`
+// members, the DiagramLayout annotations and the SynthesizedName markers.
+// Ordinary metadata on an element is content.
+func (r *Renderer) contentKind(sym *symbols.Symbol) bool {
+	if !containedKind(sym) {
+		return false
+	}
+	if sym.Kind == symbols.SymbolRenderingUsage && sym.OwnerScope != nil {
+		if owner := sym.OwnerScope.Owner(); owner != nil && semantics.IsView(owner) {
+			return false
+		}
+	}
+	return !r.model.IsLayoutAnnotation(sym) && !r.model.IsSynthesizedNameAnnotation(sym)
+}
+
 // containedKind reports whether a member is an element of the model a rendering
 // shows, as against the annotations and bookkeeping declarations that carry no
 // structure: documentation, comments, aliases and the ends of a connect clause,
diff --git a/internal/ir/view/unplaced.go b/internal/ir/view/unplaced.go
new file mode 100644
index 000000000..4ba5fbde1
--- /dev/null
+++ b/internal/ir/view/unplaced.go
@@ -0,0 +1,73 @@
+package view
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+// Unplaced is what the DOT form does with the nodes a positioned drawing leaves
+// unplaced: those with no Layout, no route meeting them and, for a cluster, no
+// placed member. The empty Unplaced is UnplacedOmit.
+type Unplaced string
+
+const (
+	// UnplacedOmit leaves them undrawn: the drawing shows what the Layouts
+	// place, and nothing lands on a placed box.
+	UnplacedOmit Unplaced = "omit"
+	// UnplacedStrip draws them in rows in a strip below the drawing, clear of
+	// the canvas, every placed box and every route.
+	UnplacedStrip Unplaced = "strip"
+)
+
+// UnplacedChoices are the placements unplaced nodes can be asked for, in the
+// order they are offered.
+func UnplacedChoices() []Unplaced { return []Unplaced{UnplacedOmit, UnplacedStrip} }
+
+// ParseUnplaced reports the placement name names, and whether it names one. The
+// empty name is no placement: the default is asked for by stating none.
+func ParseUnplaced(name string) (Unplaced, bool) {
+	for _, choice := range UnplacedChoices() {
+		if string(choice) == name {
+			return choice, true
+		}
+	}
+	return "", false
+}
+
+// UnplacedNames spells the placements as a list, for help and error text.
+func UnplacedNames() string {
+	names := make([]string, 0, len(UnplacedChoices()))
+	for _, choice := range UnplacedChoices() {
+		names = append(names, string(choice))
+	}
+	return strings.Join(names, ", ")
+}
+
+// ErrUnknownUnplaced is a placement name that names none. UnknownUnplacedError
+// wraps it.
+var ErrUnknownUnplaced = errors.New("unknown placement of unplaced nodes")
+
+// UnknownUnplacedError is a placement asked for by a name none has; it names the
+// placements there are, so no surface refuses one without saying which.
+type UnknownUnplacedError struct {
+	Name string
+}
+
+func (e *UnknownUnplacedError) Error() string {
+	return fmt.Sprintf("unknown placement %q of unplaced nodes; the placements are %s", e.Name, UnplacedNames())
+}
+
+func (e *UnknownUnplacedError) Unwrap() error { return ErrUnknownUnplaced }
+
+// check is the UnknownUnplacedError of an Unplaced value that names no
+// placement; the empty one and every named one pass.
+func (u Unplaced) check() error {
+	if u == "" {
+		return nil
+	}
+	if _, ok := ParseUnplaced(string(u)); !ok {
+		return &UnknownUnplacedError{Name: string(u)}
+	}
+	return nil
+}
diff --git a/internal/ir/view/view.go b/internal/ir/view/view.go
index 90f4ed2ea..39d68834a 100644
--- a/internal/ir/view/view.go
+++ b/internal/ir/view/view.go
@@ -179,9 +179,15 @@ type Node struct {
 	// Name is the element's name: qualified for a node the view exposes, simple
 	// for one nested in it. It is empty for an anonymous element.
 	Name string
+	// NameSynthesized marks a name the model did not give: a migration made it up, or
+	// it is the language's `start`/`done`. A name to key by, not one a picture shows.
+	NameSynthesized bool
 	// Type is the declared type of a typed usage, as the notation writes it
 	// after the colon. It is empty for a definition or an untyped usage.
 	Type string
+	// Typings are the qualified names of the elements Type resolves to, in its
+	// order; a member of one is drawn as the type's own. Empty when none resolves.
+	Typings []string
 	// Detail is what else the rendering says about the node, such as a state's
 	// "initial" or "already shown". It is empty when there is nothing to add.
 	Detail string
@@ -533,6 +539,18 @@ func declType(sym *symbols.Symbol) string {
 	return typingOf(semantics.RelationshipsOf(sym))
 }
 
+// declTypings are the qualified names, as the notation writes them, of the
+// elements a usage's declared typings resolve to.
+func (r *Renderer) declTypings(sym *symbols.Symbol) []string {
+	var names []string
+	for _, typ := range r.model.DeclaredTypes(sym) {
+		if name := r.notationName(typ); name != "" {
+			names = append(names, name)
+		}
+	}
+	return names
+}
+
 // nodeType is the type a usage lowered into a behavior graph is declared with
 // ("Provide" of `action provide : Provide`), empty for any other node.
 func nodeType(decl ast.Node) string {
diff --git a/internal/semantic/semantics/annotations.go b/internal/semantic/semantics/annotations.go
index 1d0a0125e..263d79987 100644
--- a/internal/semantic/semantics/annotations.go
+++ b/internal/semantic/semantics/annotations.go
@@ -382,15 +382,13 @@ func bodyScope(_ *ast.Usage, declared *symbols.Scope) *symbols.Scope { return de
 // aboutAnnotations returns the annotations that `metadata m about sym;`
 // declarations elsewhere in the workspace state about sym.
 func (m *Model) aboutAnnotations(sym *symbols.Symbol) []annotation {
-	if out, ok := m.annotationsAbout()[sym]; ok {
-		return out
-	}
-	// The caller may hold a symbol re-indexed from the same declaration as the
-	// one indexed here, which the declaration identifies across both trees.
-	if sym.Decl == nil {
-		return nil
+	about := m.annotationsAbout()
+	// Usages may have resolved sym across re-indexed trees, to as many symbols
+	// of one declaration; the declaration gathers what every one was told.
+	if sym.Decl != nil {
+		return m.aboutByDecl[sym.Decl]
 	}
-	return m.aboutByDecl[sym.Decl]
+	return about[sym]
 }
 
 // AboutAnnotatedSymbols returns every element an `about` metadata usage
diff --git a/internal/semantic/semantics/conjugation.go b/internal/semantic/semantics/conjugation.go
index d2db7ef78..82594153a 100644
--- a/internal/semantic/semantics/conjugation.go
+++ b/internal/semantic/semantics/conjugation.go
@@ -467,9 +467,20 @@ func (m *Model) featureTypesConform(a, b *symbols.Symbol) bool {
 
 // featureType returns the symbol a feature's typing relationship names, or nil.
 func (m *Model) featureType(sym *symbols.Symbol) *symbols.Symbol {
-	if sym == nil {
+	if types := m.DeclaredTypes(sym); len(types) > 0 {
+		return types[0]
+	}
+	return nil
+}
+
+// DeclaredTypes are the types sym's own typing relationships name, in
+// declaration order, each resolved in the scope that declares sym and followed
+// through any alias; a typing that does not resolve to an element is left out.
+func (m *Model) DeclaredTypes(sym *symbols.Symbol) []*symbols.Symbol {
+	if m == nil || sym == nil || m.resolver == nil {
 		return nil
 	}
+	var types []*symbols.Symbol
 	for _, rel := range RelationshipsOf(sym) {
 		if rel == nil || rel.Kind != ast.RelTyping || rel.Target == nil {
 			continue
@@ -482,11 +493,13 @@ func (m *Model) featureType(sym *symbols.Symbol) *symbols.Symbol {
 		if !isQN {
 			continue
 		}
-		if resolved, ok := m.resolver.ResolveQualified(sym.OwnerScope, qn); ok {
-			if canonical, aliasOK := m.resolver.ResolveAliasTarget(resolved); aliasOK {
-				return canonical
-			}
+		resolved, ok := m.resolver.ResolveQualified(sym.OwnerScope, qn)
+		if !ok {
+			continue
+		}
+		if canonical, aliasOK := m.resolver.ResolveAliasTarget(resolved); aliasOK {
+			types = append(types, canonical)
 		}
 	}
-	return nil
+	return types
 }
diff --git a/internal/semantic/semantics/layout.go b/internal/semantic/semantics/layout.go
index c3711dd1a..0f8a0bcc4 100644
--- a/internal/semantic/semantics/layout.go
+++ b/internal/semantic/semantics/layout.go
@@ -143,6 +143,39 @@ func (m *Model) LayoutSitesOf(sym *symbols.Symbol) []*LayoutSite {
 	return out
 }
 
+// IsLayoutAnnotation reports whether sym is a metadata usage typed by one of
+// the DiagramLayout definitions: a statement about a picture, not model content.
+func (m *Model) IsLayoutAnnotation(sym *symbols.Symbol) bool {
+	switch m.annotationTypeFQN(sym) {
+	case LayoutFQN, RouteFQN, CanvasFQN:
+		return true
+	}
+	return false
+}
+
+// annotationTypeFQN is the qualified name of the metadata definition sym
+// states as a metadata usage or prefix metadata, "" for any other symbol.
+func (m *Model) annotationTypeFQN(sym *symbols.Symbol) string {
+	if m == nil || sym == nil || m.resolver == nil {
+		return ""
+	}
+	var a annotation
+	var ok bool
+	switch decl := sym.Decl.(type) {
+	case *ast.Usage:
+		if decl.Kind != ast.UsageMetadata {
+			return ""
+		}
+		a, ok = m.usageAnnotation(sym.OwnerScope, decl)
+	case *ast.PrefixMetadata:
+		a, ok = m.prefixAnnotation(sym.OwnerScope, decl)
+	}
+	if !ok || a.typ == nil {
+		return ""
+	}
+	return m.fqnOf(a.typ)
+}
+
 // LayoutOf resolves the Layout of elem as drawn in view: the first Layout
 // annotation stated in the view's body, else the first one applying in every
 // view. With no view — a rendering of elements outside any view — only the
diff --git a/internal/semantic/semantics/synthesized_name.go b/internal/semantic/semantics/synthesized_name.go
new file mode 100644
index 000000000..7bb832f01
--- /dev/null
+++ b/internal/semantic/semantics/synthesized_name.go
@@ -0,0 +1,28 @@
+package semantics
+
+import "github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+
+// SynthesizedNameFQN is the qualified name of the metadata definition in the
+// bundled library that marks a name a migration made up for an element its
+// source left anonymous.
+const SynthesizedNameFQN = "MigrationMetadata::SynthesizedName"
+
+// NameSynthesized reports whether sym's name was made up by a migration: a
+// SynthesizedName annotation applies to it, stated on it or about it.
+func (m *Model) NameSynthesized(sym *symbols.Symbol) bool {
+	if m == nil || sym == nil || m.resolver == nil {
+		return false
+	}
+	for _, a := range m.annotationsOf(sym) {
+		if a.typ != nil && m.fqnOf(a.typ) == SynthesizedNameFQN {
+			return true
+		}
+	}
+	return false
+}
+
+// IsSynthesizedNameAnnotation reports whether sym is a metadata usage typed by
+// SynthesizedName: a record of the migration, not model content.
+func (m *Model) IsSynthesizedNameAnnotation(sym *symbols.Symbol) bool {
+	return m.annotationTypeFQN(sym) == SynthesizedNameFQN
+}
diff --git a/internal/syntax/source/name.go b/internal/syntax/source/name.go
index 90e56862b..bf796c02c 100644
--- a/internal/syntax/source/name.go
+++ b/internal/syntax/source/name.go
@@ -93,6 +93,43 @@ func ReferenceEndNames(text string) string {
 	}
 }
 
+// ReferenceQualifiedNames reads a typing's references — `, ` apart, `$::` led or
+// `~` conjugated — into each one's names; a feature chain, or text that does not
+// read as references, contributes none.
+func ReferenceQualifiedNames(text string) [][]string {
+	var refs [][]string
+	rest := text
+	for {
+		rest = strings.TrimPrefix(strings.TrimPrefix(rest, "~"), "$::")
+		var names []string
+		chain := false
+		for {
+			name, after, ok := readBasicOrQuotedName(rest)
+			if !ok {
+				return nil
+			}
+			names, rest = append(names, name), after
+			if strings.HasPrefix(rest, "::") {
+				rest = rest[2:]
+			} else if strings.HasPrefix(rest, ".") {
+				rest, chain = rest[1:], true
+			} else {
+				break
+			}
+		}
+		if !chain {
+			refs = append(refs, names)
+		}
+		if rest == "" {
+			return refs
+		}
+		if !strings.HasPrefix(rest, ", ") {
+			return nil
+		}
+		rest = rest[2:]
+	}
+}
+
 // readName reads one name off the front of text: a quoted one up to its closing
 // quote, else a bare one up to `::`.
 func readName(text string) (name, rest string, ok bool) {
diff --git a/internal/syntax/source/name_test.go b/internal/syntax/source/name_test.go
index aebcb7ab4..62e9d27bd 100644
--- a/internal/syntax/source/name_test.go
+++ b/internal/syntax/source/name_test.go
@@ -51,3 +51,27 @@ func TestReferenceEndNames(t *testing.T) {
 		}
 	}
 }
+
+func TestReferenceQualifiedNames(t *testing.T) {
+	for _, tc := range []struct {
+		text string
+		want [][]string
+	}{
+		{"Pump", [][]string{{"Pump"}}},
+		{"Plant::Pumps::Pump", [][]string{{"Plant", "Pumps", "Pump"}}},
+		{"$::ISQ::LengthValue", [][]string{{"ISQ", "LengthValue"}}},
+		{"~Ports::FuelPort", [][]string{{"Ports", "FuelPort"}}},
+		{"Plant::Pumps::Pump, ~Ports::FuelPort", [][]string{{"Plant", "Pumps", "Pump"}, {"Ports", "FuelPort"}}},
+		{"'Sep::Pkg'::'x::y'", [][]string{{"Sep::Pkg", "x::y"}}},
+		{"vehicle.engine.Cylinder", nil},
+		{"Plant::pump.'fuel in', Pump", [][]string{{"Pump"}}},
+		{"", nil},
+		{"T<U>", nil},
+		{"A::", nil},
+		{"A,B", nil},
+	} {
+		if got := ReferenceQualifiedNames(tc.text); !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("ReferenceQualifiedNames(%q) = %q, want %q", tc.text, got, tc.want)
+		}
+	}
+}
diff --git a/internal/translate/migrate/activity.go b/internal/translate/migrate/activity.go
index 29bc3abe9..697d62515 100644
--- a/internal/translate/migrate/activity.go
+++ b/internal/translate/migrate/activity.go
@@ -258,7 +258,7 @@ func (a *activity) name(n *sysmlv1.Element, base string) string {
 		name = a.m.nameOf(n)
 		if name == "" || a.used[name] || a.m.taken[a.def][name] {
 			if name == "" {
-				name = base
+				name, a.m.synthesized[n] = base, true
 			}
 			name = a.fresh(name)
 		}
@@ -284,6 +284,11 @@ func (a *activity) edgeFresh(e *sysmlv1.Element, base string) string {
 	return ""
 }
 
+// madeUp records a made-up member name, written, for the body's SynthesizedName marker.
+func (a *activity) madeUp(written string) {
+	a.m.w.madeUp(written)
+}
+
 // fresh returns base, or base with a number, not yet used in the body.
 func (a *activity) fresh(base string) string {
 	name := base
@@ -676,6 +681,7 @@ func (a *activity) startSuccessions() {
 		f := a.fresh("fork")
 		a.m.w.line(firstKw + from + thenKw + writeName(f) + ";")
 		a.m.w.line("fork " + writeName(f) + ";")
+		a.madeUp(writeName(f))
 		from = writeName(f)
 	}
 	for _, t := range targets {
@@ -711,6 +717,7 @@ func (a *activity) succession(edges []*sysmlv1.Element, from, guard, to, tail st
 	for _, e := range edges {
 		if name = a.edgeFresh(e, spoken(from)+" to "+spoken(to)); name != "" {
 			line = "succession " + writeName(name) + " " + line
+			a.m.madeUp(e, writeName(name))
 			break
 		}
 	}
@@ -729,12 +736,14 @@ func (a *activity) startPrologue() string {
 		name := a.fresh("keep")
 		a.m.w.line("first start then " + writeName(name) + ";")
 		a.m.w.block(actionKw+writeName(name), func() { a.m.w.line(a.keeping) })
+		a.madeUp(writeName(name))
 		from = writeName(name)
 	}
 	for _, n := range a.nodes {
 		if s, ok := a.before[n]; ok && nodeKind(n) == nodeInitial {
 			a.m.w.line(firstKw + from + thenKw + s.name + ";")
 			a.m.w.block(actionKw+s.name, func() { a.m.w.lines(s.lines) })
+			a.madeUp(s.name)
 			from = s.name
 		}
 	}
@@ -742,6 +751,7 @@ func (a *activity) startPrologue() string {
 		name := a.fresh("wait")
 		a.m.w.line(firstKw + from + thenKw + writeName(name) + ";")
 		a.m.w.line(actionKw + writeName(name) + " accept after " + w + ";")
+		a.madeUp(writeName(name))
 		from = writeName(name)
 	}
 	return from
@@ -876,6 +886,7 @@ func (a *activity) successions(n *sysmlv1.Element) {
 	if s, ok := a.after[n]; ok {
 		a.m.w.line(firstKw + from + thenKw + s.name + ";")
 		a.m.w.block(actionKw+s.name, func() { a.m.w.lines(s.lines) })
+		a.madeUp(s.name)
 		from = s.name
 	}
 	outs := a.succ[n]
@@ -883,6 +894,7 @@ func (a *activity) successions(n *sysmlv1.Element) {
 		f := a.fresh("fork")
 		a.m.w.line(firstKw + from + thenKw + writeName(f) + ";")
 		a.m.w.line("fork " + writeName(f) + ";")
+		a.madeUp(writeName(f))
 		from = writeName(f)
 		a.m.downgrade(n, "several edges leave the node, which a fork "+f+" carries")
 	}
@@ -1310,6 +1322,7 @@ func (a *activity) declare(n *sysmlv1.Element) {
 	name := writeName(a.name(n, baseName(n)))
 	a.leadIn(n, name)
 	a.declareNode(n, name)
+	a.m.madeUp(n, name)
 	a.m.declared[n] = true
 }
 
@@ -1319,21 +1332,25 @@ func (a *activity) leadIn(n *sysmlv1.Element, into string) {
 	if w, ok := a.waits[n]; ok {
 		a.m.w.line(actionKw + w.name + " accept after " + w.delay + ";")
 		a.m.w.line(firstKw + w.name + thenKw + into + ";")
+		a.madeUp(w.name)
 		into = w.name
 	}
 	if s, ok := a.before[n]; ok {
 		a.m.w.block(actionKw+s.name, func() { a.m.w.lines(s.lines) })
 		a.m.w.line(firstKw + s.name + thenKw + into + ";")
+		a.madeUp(s.name)
 		into = s.name
 	}
 	if j, ok := a.joins[n]; ok {
 		a.m.w.line("join " + j + ";")
 		a.m.w.line(firstKw + j + thenKw + into + ";")
+		a.madeUp(j)
 		a.m.add(n, Approximated, "", "several edges lead to the node, which waits for all of them through the join "+j)
 	}
 	if m, ok := a.merges[n]; ok {
 		a.m.w.line("merge " + m + ";")
 		a.m.w.line(firstKw + m + thenKw + into + ";")
+		a.madeUp(m)
 	}
 }
 
@@ -1748,13 +1765,15 @@ func (a *activity) dataEdge(e, s, tgt *sysmlv1.Element, from, to string) {
 	if nodeKind(s) == nodeParam || nodeKind(tgt) == nodeParam {
 		kw, decl, base = "binding", "bind "+to+" = "+from, spoken(to)+" = "+spoken(from)
 	}
-	name := a.edgeFresh(a.namer(e, s, tgt), base)
+	namer := a.namer(e, s, tgt)
+	name := a.edgeFresh(namer, base)
 	if name != "" {
 		if kw == "flow" {
 			decl = "flow " + writeName(name) + " from " + from + " to " + to
 		} else {
 			decl = kw + " " + writeName(name) + " " + decl
 		}
+		a.m.madeUp(namer, writeName(name))
 	}
 	a.m.w.line(decl + ";")
 	a.m.wroteEdge(e, a.def, kw, name)
diff --git a/internal/translate/migrate/behavior.go b/internal/translate/migrate/behavior.go
index 6c1a38536..f10e19bb2 100644
--- a/internal/translate/migrate/behavior.go
+++ b/internal/translate/migrate/behavior.go
@@ -128,6 +128,7 @@ func (m *migration) behaviorBody(e *sysmlv1.Element, cat category) {
 		m.opaqueBehaviorBody(e, e)
 	}
 	m.stereotypeAnnotations(e)
+	m.w.markMadeUp(m.synthesizedNames)
 	m.scope = saved
 }
 
@@ -300,6 +301,7 @@ func (m *migration) parameter(p, scope *sysmlv1.Element, declared map[string]boo
 		note = joinNotes("bound to "+bound+", "+what, note)
 	}
 	m.add(p, v, m.v2Name(p), note)
+	m.madeUp(p, writeName(name))
 	m.w.block(b.String(), func() {
 		m.comments(p)
 		m.w.lines(body)
diff --git a/internal/translate/migrate/diagrams_internal_test.go b/internal/translate/migrate/diagrams_internal_test.go
index d90adb751..8d11ab5b8 100644
--- a/internal/translate/migrate/diagrams_internal_test.go
+++ b/internal/translate/migrate/diagrams_internal_test.go
@@ -168,7 +168,7 @@ func TestDiagramViews(t *testing.T) {
 			   <ownedEnd xmi:type="uml:Property" xmi:id="_a_end" type="_pump" association="_feeds"/>
 			 </packagedElement>`,
 			diagram("_d", "Feeding", "_sys", "SysML Block Definition Diagram", "_a_end"),
-			[]string{"connection def Feeds {\n    end pump2 : Sys::Pump;\n    end pump : Sys::Pump;\n}", "view Feeding {\n        expose Feeds::pump;\n        render Views::asTreeDiagram;\n    }"}, Mapped, ""},
+			[]string{"connection def Feeds {\n    end pump2 : Sys::Pump;\n    end pump : Sys::Pump;\n    metadata MigrationMetadata::SynthesizedName about pump;\n}", "view Feeding {\n        expose Feeds::pump;\n        render Views::asTreeDiagram;\n    }"}, Mapped, ""},
 		{"a shown primitive is exposed past a member named like its library package",
 			`<packagedElement xmi:type="uml:Class" xmi:id="_svs" name="ScalarValues"/>
 			 <packagedElement xmi:type="uml:Class" xmi:id="_tank" name="Tank">
@@ -199,7 +199,7 @@ func TestDiagramViews(t *testing.T) {
 		{"a state machine diagram exposes the state def whose graph it draws, its states drawn by the graph",
 			machineMembers,
 			diagram("_d", "Modes", "_sm", "SysML State Machine Diagram", "_idle", "_run", "_t_go", "_sm_init"),
-			[]string{"state def Modes {\n    view Modes : StandardViewDefinitions::StateTransitionView {\n        expose $::Modes;\n        render Views::asInterconnectionDiagram;\n    }\n    entry; then Idle;\n    state Idle;\n    state Run;\n    transition 'Idle accept Go then Run' first Idle accept Go then Run;\n}"},
+			[]string{"state def Modes {\n    view Modes : StandardViewDefinitions::StateTransitionView {\n        expose $::Modes;\n        render Views::asInterconnectionDiagram;\n    }\n    entry; then Idle;\n    state Idle;\n    state Run;\n    transition 'Idle accept Go then Run' first Idle accept Go then Run;\n    metadata MigrationMetadata::SynthesizedName about 'Idle accept Go then Run';\n}"},
 			Mapped, "the view exposes state def Modes, whose graph the rendering draws with the 4 shown nodes and edges of it"},
 		{"a diagram of a composite state is drawn as the graph of the state def its machine is written as",
 			`<packagedElement xmi:type="uml:StateMachine" xmi:id="_sm" name="Modes">
diff --git a/internal/translate/migrate/edges.go b/internal/translate/migrate/edges.go
index a2de0d573..10de7f48d 100644
--- a/internal/translate/migrate/edges.go
+++ b/internal/translate/migrate/edges.go
@@ -72,6 +72,7 @@ func (m *migration) edgeName(e *sysmlv1.Element, base string) string {
 	if n := m.nameOf(e); n != "" {
 		return n
 	}
+	m.synthesized[e] = true
 	return base
 }
 
diff --git a/internal/translate/migrate/migrate.go b/internal/translate/migrate/migrate.go
index 8e575863e..440098b86 100644
--- a/internal/translate/migrate/migrate.go
+++ b/internal/translate/migrate/migrate.go
@@ -102,6 +102,7 @@ func FromModelOptions(name string, model *sysmlv1.Model, opts Options) *Result {
 		results:      &simresults.Results{Source: name, Configurations: []simresults.ConfigurationResults{}},
 		w:            &writer{},
 		names:        map[*sysmlv1.Element]string{},
+		synthesized:  map[*sysmlv1.Element]bool{},
 		nodeNames:    map[*sysmlv1.Element]string{},
 		declared:     map[*sysmlv1.Element]bool{},
 		placeholders: map[*sysmlv1.Element]bool{},
@@ -166,6 +167,7 @@ func FromModelOptions(name string, model *sysmlv1.Model, opts Options) *Result {
 		objectives:   map[*sysmlv1.Element]string{},
 		routeKinds:   routeKinds{},
 	}
+	m.w.marker = m.synthesizedNames
 	if opts.Layout != nil {
 		m.layoutSummary = &LayoutSummary{
 			Source:       opts.LayoutSource,
@@ -260,6 +262,9 @@ type migration struct {
 	// activity nodes are written under, fixed by their writer or ahead of it.
 	names     map[*sysmlv1.Element]string
 	nodeNames map[*sysmlv1.Element]string
+	// synthesized marks the elements whose written name the migration made up,
+	// their source having left them unnamed; see madeUp.
+	synthesized map[*sysmlv1.Element]bool
 	// declared marks the activity nodes their graph's writer declared as members.
 	declared map[*sysmlv1.Element]bool
 	// placeholders are the activity nodes written as inert placeholders, and nodeEnds
@@ -831,6 +836,7 @@ func (m *migration) body(e *sysmlv1.Element) {
 	m.scope = e
 	m.comments(e)
 	m.members(e)
+	m.w.markMadeUp(m.synthesizedNames)
 	m.scope = saved
 }
 
@@ -960,6 +966,7 @@ func (m *migration) classifier(e *sysmlv1.Element) {
 		verdict = Approximated
 		note = joinNotes(note, n)
 	}
+	m.madeUp(e, writeName(name))
 	if cat == catSimConfig {
 		m.simulationConfig(e, header, note)
 		return
@@ -1350,6 +1357,7 @@ func (m *migration) individualBody(e *sysmlv1.Element) {
 		for _, l := range lines {
 			m.w.line(l)
 		}
+		m.madeUp(f, writeName(m.nameFor(f)))
 		m.add(slot, verdictFor(note), m.v2Name(e)+"::"+writeName(m.nameFor(f)), note)
 	}
 	recorded()
@@ -1582,6 +1590,7 @@ func (m *migration) verificationBody(e *sysmlv1.Element) {
 		decl := "objective"
 		if name := m.objectives[e]; name != "" {
 			decl += " " + writeName(name)
+			m.w.madeUp(writeName(name))
 		}
 		m.w.block(decl, func() {
 			for _, extra := range extras {
@@ -1599,6 +1608,7 @@ func (m *migration) verificationBody(e *sysmlv1.Element) {
 	}
 	m.views(e)
 	m.stereotypeAnnotations(e)
+	m.w.markMadeUp(m.synthesizedNames)
 	m.scope = saved
 }
 
@@ -1669,8 +1679,10 @@ func (m *migration) association(e *sysmlv1.Element) {
 		}
 		m.views(e)
 		m.stereotypeAnnotations(e)
+		m.w.markMadeUp(m.synthesizedNames)
 		m.scope = saved
 	})
+	m.madeUp(e, writeName(name))
 }
 
 // nameEnds settles the names the connection def written for association e
@@ -1718,6 +1730,7 @@ func (m *migration) associationEnd(e, end *sysmlv1.Element) {
 	decl += mult + collection(end) + ";"
 	tnote = joinNotes(tnote, mnote)
 	m.w.line(decl)
+	m.madeUp(end, writeName(endName))
 	if end.Parent == e {
 		m.add(end, verdictFor(tnote), m.v2Name(e)+"::"+writeName(endName), tnote)
 	}
@@ -1916,6 +1929,9 @@ func (m *migration) feature(p *sysmlv1.Element) {
 		m.scope = p
 		m.comments(p)
 		m.w.lines(bodyLines)
+		if payload != "" {
+			m.madeUp(p, writeName(m.nameFor(p)))
+		}
 		for _, c := range p.Children {
 			if c.Role != "defaultValue" {
 				m.member(c)
@@ -1925,8 +1941,12 @@ func (m *migration) feature(p *sysmlv1.Element) {
 			extra()
 		}
 		m.stereotypeAnnotations(p)
+		m.w.markMadeUp(m.synthesizedNames)
 		m.scope = saved
 	})
+	if name != "" {
+		m.madeUp(p, writeName(name))
+	}
 }
 
 // featureVisibility returns the visibility prefix written for a feature and
@@ -2479,6 +2499,7 @@ func (m *migration) connector(c *sysmlv1.Element) {
 	}
 	m.wroteEdge(c, m.scope, kw, m.nameOf(c))
 	m.w.block(decl, func() { m.metadataUsages(c) })
+	m.madeUp(c, writeName(m.nameOf(c)))
 	m.add(c, Mapped, target, note)
 	m.stereotypeComments(c)
 	for _, f := range m.flows[c] {
@@ -3000,6 +3021,7 @@ func (m *migration) dependencyPair(d *sysmlv1.Element, pl *placement, name strin
 	decl := "dependency "
 	if name != "" {
 		decl += writeName(name) + " from "
+		m.madeUp(d, writeName(name))
 	}
 	decl += from + " to " + to
 	switch {
@@ -3059,6 +3081,7 @@ func (m *migration) satisfy(d, client, req *sysmlv1.Element, name string) (strin
 		decl := "satisfy requirement "
 		if name != "" {
 			decl += writeName(name) + " "
+			m.madeUp(d, writeName(name))
 		}
 		decl += ": " + m.ref(req, scope)
 		if by != "" {
@@ -3123,6 +3146,7 @@ func (m *migration) verify(d, client, req *sysmlv1.Element, name string) (string
 		decl := "verify requirement "
 		if name != "" {
 			decl += writeName(name) + " "
+			m.madeUp(d, writeName(name))
 		}
 		m.w.block(decl+": "+m.ref(req, client), func() { m.metadataUsages(d) })
 	})
diff --git a/internal/translate/migrate/names.go b/internal/translate/migrate/names.go
index 29e13c69a..66602fef8 100644
--- a/internal/translate/migrate/names.go
+++ b/internal/translate/migrate/names.go
@@ -49,10 +49,32 @@ func (m *migration) nameFor(e *sysmlv1.Element) string {
 	for i := 2; m.nameTaken(e.Parent, name); i++ {
 		name = fmt.Sprintf("%s%d", base, i)
 	}
-	m.names[e] = name
+	m.names[e], m.synthesized[e] = name, true
 	return name
 }
 
+// madeUp records that the block being written declares e under name, a name
+// the migration made up when e's source left it unnamed: the block's
+// SynthesizedName marker lists it. written is the name as the notation writes it.
+func (m *migration) madeUp(e *sysmlv1.Element, written string) {
+	if m.synthesized[e] && written != "" {
+		m.w.madeUp(written)
+	}
+}
+
+// synthesizedNameFQN names the library metadata marking a made-up name.
+const synthesizedNameFQN = "MigrationMetadata::SynthesizedName"
+
+// synthesizedNames is the metadata usage marking the members of the current
+// scope written under made-up names, each as the notation wrote it.
+func (m *migration) synthesizedNames(written []string) string {
+	prefix := ""
+	if m.shadowsLibrary("MigrationMetadata", m.scope) {
+		prefix = "$::"
+	}
+	return "metadata " + prefix + synthesizedNameFQN + " about " + strings.Join(written, ", ") + ";"
+}
+
 // writtenName returns the name e's v2 declaration bears, as a query reads it back:
 // nameOf, or the one the write gives an anonymous declaration that needs a name.
 func (m *migration) writtenName(e *sysmlv1.Element) string {
diff --git a/internal/translate/migrate/states.go b/internal/translate/migrate/states.go
index f59b3e060..522b3c119 100644
--- a/internal/translate/migrate/states.go
+++ b/internal/translate/migrate/states.go
@@ -95,7 +95,7 @@ func (m *migration) nameRegions(regions []*sysmlv1.Element, owner *sysmlv1.Eleme
 		for _, r := range regions {
 			rname := m.nameOf(r)
 			if rname == "" {
-				rname = "region"
+				rname, m.synthesized[r] = "region", true
 			}
 			m.names[r] = freshIn(inner, rname)
 			m.parallel[r] = name
@@ -471,7 +471,7 @@ func (m *migration) nameVertex(v, owner *sysmlv1.Element, used map[string]bool)
 	name := m.nameOf(v)
 	switch {
 	case name == "":
-		name = m.freshMember(owner, used, base)
+		name, m.synthesized[v] = m.freshMember(owner, used, base), true
 	case used[name]:
 		name = freshIn(used, name)
 	}
@@ -545,9 +545,11 @@ func (m *migration) regions(owner *sysmlv1.Element, regions []*sysmlv1.Element,
 					st.enter(false)
 					st.write()
 				})
+				m.madeUp(r, writeName(rname))
 				m.add(r, Mapped, rname, "an orthogonal region is written as a sub-state of the parallel state "+name)
 			}
 		})
+		m.w.madeUp(writeName(name))
 		m.w.line("transition first " + writeName(name) + " then done;")
 	}
 }
@@ -750,18 +752,22 @@ func (s *stateRegion) vertex(v *sysmlv1.Element) {
 		case "choice", "junction":
 			name := writeName(s.name(v))
 			s.m.w.line(pseudoKind(v) + " " + name + ";")
+			s.m.madeUp(v, name)
 			s.m.add(v, Mapped, name, "written as a "+pseudoKind(v)+" pseudostate, whose guarded transitions the runtime reads when it is reached; an unguarded one is its else branch")
 		case "fork", "join":
 			name := writeName(s.name(v))
 			s.m.w.line(pseudoKind(v) + " " + name + ";")
+			s.m.madeUp(v, name)
 			s.m.add(v, Mapped, name, "written as a "+pseudoKind(v)+" pseudostate, whose segments the runtime fires together")
 		case "shallowHistory":
 			name := writeName(s.name(v))
 			s.m.w.line("history " + name + ";")
+			s.m.madeUp(v, name)
 			s.m.add(v, Mapped, name, "written as a shallow history, which re-enters the substate active when its state was last left")
 		case "deepHistory":
 			name := writeName(s.name(v))
 			s.m.w.line("deep history " + name + ";")
+			s.m.madeUp(v, name)
 			s.m.add(v, Mapped, name, "written as a deep history, which re-enters the innermost states active when its state was last left")
 		case "terminate":
 			s.m.add(v, Approximated, "done", "a terminate pseudostate ends the machine; a transition to it is written to done, which ends its region")
@@ -790,6 +796,7 @@ func (m *migration) connectionPoint(v *sysmlv1.Element) {
 		return
 	}
 	m.w.line(stateKw + writeName(name) + ";")
+	m.madeUp(v, writeName(name))
 	if pseudoKind(v) == "exitPoint" {
 		m.add(v, Mapped, name, "written as a state; a transition leaving a submachine state through the exit point leaves this state")
 		return
@@ -811,6 +818,7 @@ func (m *migration) statePoints(v *sysmlv1.Element) int {
 		default:
 			name := writeName(m.vertexNames[cp])
 			m.w.line(f.kw + " " + name + ";")
+			m.madeUp(cp, name)
 			m.add(cp, Mapped, name, f.note)
 			written++
 		}
@@ -833,6 +841,7 @@ func (m *migration) writtenPoints(v *sysmlv1.Element) int {
 // with its entry, do and exit actions, deferrals and regions.
 func (s *stateRegion) state(v *sysmlv1.Element) {
 	name := writeName(s.name(v))
+	s.m.madeUp(v, name)
 	defers := s.deferrals(v)
 	head := s.stateHead(v, name)
 	regions := s.m.populatedRegions(v)
@@ -1467,6 +1476,7 @@ func (s *stateRegion) writeAccepts(t *sysmlv1.Element, accepts []acceptance, tna
 				n = s.m.freshMember(s.owner, s.used, s.furtherName(t, tname, accept, guard, from, to))
 				s.m.wroteEdgeAlso(t, s.r, "transition", nil, n)
 			}
+			s.m.madeUp(t, writeName(n))
 			line += writeName(n) + " "
 		}
 		line += "first " + from + accept.clause + guard
diff --git a/internal/translate/migrate/synthesized_names_internal_test.go b/internal/translate/migrate/synthesized_names_internal_test.go
new file mode 100644
index 000000000..6317a2944
--- /dev/null
+++ b/internal/translate/migrate/synthesized_names_internal_test.go
@@ -0,0 +1,62 @@
+package migrate
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestSynthesizedNamesMarked covers declarations the migrator names itself: each
+// written one is listed by the SynthesizedName marker of the body holding it.
+func TestSynthesizedNamesMarked(t *testing.T) {
+	for _, tc := range []struct {
+		name, members string
+		wantNotation  []string
+	}{
+		{"an anonymous parameter",
+			`<packagedElement xmi:type="uml:Activity" xmi:id="_b" name="Run">
+			   <ownedParameter xmi:type="uml:Parameter" xmi:id="_p" direction="in">
+			     <type xmi:type="uml:PrimitiveType" href="http://www.omg.org/spec/UML/20131001/PrimitiveTypes.xmi#Real"/>
+			   </ownedParameter>
+			 </packagedElement>`,
+			[]string{"action def Run {\n    in real : ScalarValues::Real;\n    metadata MigrationMetadata::SynthesizedName about real;\n}"}},
+		{"an anonymous port's payload",
+			`<packagedElement xmi:type="uml:Class" xmi:id="_c" name="Ctrl">
+			   <ownedAttribute xmi:type="uml:Port" xmi:id="_q" type="_pump" aggregation="composite"/>
+			 </packagedElement>`,
+			[]string{"port {\n        ref item pump : Sys::Pump;\n        metadata MigrationMetadata::SynthesizedName about pump;\n    }\n}"}},
+		{"an include named after its addition",
+			`<packagedElement xmi:type="uml:UseCase" xmi:id="_uc" name="Drive">
+			   <include xmi:type="uml:Include" xmi:id="_inc" addition="_start"/>
+			 </packagedElement>
+			 <packagedElement xmi:type="uml:UseCase" xmi:id="_start" name="Start"/>`,
+			[]string{"use case def Drive {\n    include use case start : Start;\n    metadata MigrationMetadata::SynthesizedName about start;\n}"}},
+		{"an instance's slot of an anonymous feature",
+			`<packagedElement xmi:type="uml:Class" xmi:id="_tank" name="Tank">
+			   <ownedAttribute xmi:type="uml:Property" xmi:id="_f">
+			     <type xmi:type="uml:PrimitiveType" href="http://www.omg.org/spec/UML/20131001/PrimitiveTypes.xmi#Real"/>
+			   </ownedAttribute>
+			 </packagedElement>
+			 <packagedElement xmi:type="uml:InstanceSpecification" xmi:id="_t1" name="t1" classifier="_tank">
+			   <slot xmi:type="uml:Slot" xmi:id="_s" definingFeature="_f">
+			     <value xmi:type="uml:LiteralReal" xmi:id="_v" value="2.5"/>
+			   </slot>
+			 </packagedElement>`,
+			[]string{"attribute :>> real = 2.5;\n    metadata MigrationMetadata::SynthesizedName about real;"}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			r, err := Migrate("names.xmi", []byte(diagramModel(tc.members, "", `<sysml:Block xmi:id="_sb2" base_Class="_tank"/>`)))
+			if err != nil {
+				t.Fatal(err)
+			}
+			got := string(r.Notation)
+			for _, w := range tc.wantNotation {
+				if !strings.Contains(got, w) {
+					t.Errorf("notation lacks %q:\n%s", w, got)
+				}
+			}
+			if strings.Contains(got, "about ''") {
+				t.Errorf("an anonymous declaration is marked:\n%s", got)
+			}
+		})
+	}
+}
diff --git a/internal/translate/migrate/usecase.go b/internal/translate/migrate/usecase.go
index 15bdfb960..5db4f51db 100644
--- a/internal/translate/migrate/usecase.go
+++ b/internal/translate/migrate/usecase.go
@@ -111,6 +111,7 @@ func (m *migration) subjects(e *sysmlv1.Element) {
 			}
 		}
 		name := m.freshName(e, lowerFirst(m.nameFor(s)))
+		m.w.madeUp(writeName(name))
 		if first {
 			m.w.line("subject " + writeName(name) + m.typing(s) + m.ref(s, e) + ";")
 			first = false
@@ -163,8 +164,9 @@ func (m *migration) include(inc *sysmlv1.Element) {
 	name := m.nameOf(inc)
 	if name == "" {
 		name = m.freshName(inc.Parent, lowerFirst(m.nameFor(added)))
-		m.names[inc] = name
+		m.names[inc], m.synthesized[inc] = name, true
 	}
+	m.madeUp(inc, writeName(name))
 	m.wroteEdge(inc, m.scope, "include", name)
 	m.w.line("include use case " + writeName(name) + " : " + m.ref(added, m.scope) + ";")
 	m.add(inc, Mapped, m.v2Name(inc), "")
@@ -202,6 +204,7 @@ func (m *migration) extend(ext *sysmlv1.Element) {
 	if name != "" {
 		decl += writeName(name) + " from "
 		target = m.v2Name(ext)
+		m.madeUp(ext, writeName(name))
 	}
 	m.wroteEdge(ext, m.scope, "dependency", name)
 	m.w.line(decl + from + " to " + to + "; /* " + comment + " */")
diff --git a/internal/translate/migrate/usecase_internal_test.go b/internal/translate/migrate/usecase_internal_test.go
index 8b6dfa1d4..bbfb5d5b1 100644
--- a/internal/translate/migrate/usecase_internal_test.go
+++ b/internal/translate/migrate/usecase_internal_test.go
@@ -33,7 +33,7 @@ func TestUseCaseForms(t *testing.T) {
 	}{
 		{"a use case with a subject is a use case def",
 			`<packagedElement xmi:type="uml:UseCase" xmi:id="_uc" name="Buy" subject="_shop"/>`, "",
-			[]string{"use case def Buy {\n    subject shop : Shop;\n}"}, "_uc", Mapped},
+			[]string{"use case def Buy {\n    subject shop : Shop;\n    metadata MigrationMetadata::SynthesizedName about shop;\n}"}, "_uc", Mapped},
 		{"an incidental stereotype does not change the form",
 			`<packagedElement xmi:type="uml:UseCase" xmi:id="_uc" name="Buy"/>`,
 			`<Custom:HyperlinkOwner xmi:id="_st" base_Element="_uc"/>`,
@@ -53,7 +53,7 @@ func TestUseCaseForms(t *testing.T) {
 			   <nestedClassifier xmi:type="uml:Class" xmi:id="_sys" name="System"/>
 			 </packagedElement>`,
 			`<sysml:Block xmi:id="_st1" base_Class="_rep"/><sysml:Block xmi:id="_st2" base_Class="_sys"/>`,
-			[]string{"use case def Review {\n    subject system : Report::System;\n}"}, "_uc", Mapped},
+			[]string{"use case def Review {\n    subject system : Report::System;\n    metadata MigrationMetadata::SynthesizedName about system;\n}"}, "_uc", Mapped},
 		{"an association-owned actor end is an actor of the use case",
 			`<packagedElement xmi:type="uml:UseCase" xmi:id="_uc" name="Buy"/>
 			 <packagedElement xmi:type="uml:Association" xmi:id="_a" memberEnd="_e1 _e2">
diff --git a/internal/translate/migrate/views.go b/internal/translate/migrate/views.go
index 8f0f06b31..fd3307b9a 100644
--- a/internal/translate/migrate/views.go
+++ b/internal/translate/migrate/views.go
@@ -406,6 +406,7 @@ func (m *migration) stakeholder(vp *sysmlv1.Element, id string) {
 		return
 	}
 	name := m.freshName(vp, lowerFirst(m.nameFor(s)))
+	m.w.madeUp(writeName(name))
 	m.w.line("stakeholder " + writeName(name) + " : " + m.ref(s, vp) + ";")
 }
 
diff --git a/internal/translate/migrate/views_internal_test.go b/internal/translate/migrate/views_internal_test.go
index 5b1da6acf..96be19675 100644
--- a/internal/translate/migrate/views_internal_test.go
+++ b/internal/translate/migrate/views_internal_test.go
@@ -37,7 +37,7 @@ func TestViewForms(t *testing.T) {
 	}{
 		{"a viewpoint carries its purpose and stakeholders",
 			``, ``,
-			[]string{"viewpoint Ops {\n    doc /* Run the pump. */\n    subject;\n    stakeholder operator : Operator;\n}"}, "_vp", Mapped},
+			[]string{"viewpoint Ops {\n    doc /* Run the pump. */\n    subject;\n    stakeholder operator : Operator;\n    metadata MigrationMetadata::SynthesizedName about operator;\n}"}, "_vp", Mapped},
 		{"a concern tag frames a concern",
 			`<packagedElement xmi:type="uml:Class" xmi:id="_vp2" name="Safety"/>`,
 			`<sysml:Viewpoint xmi:id="_sv2" base_Class="_vp2" concern="Is it safe?"/>`,
diff --git a/internal/translate/migrate/writer.go b/internal/translate/migrate/writer.go
index 98d71789d..7e8a7a07f 100644
--- a/internal/translate/migrate/writer.go
+++ b/internal/translate/migrate/writer.go
@@ -9,10 +9,20 @@ import (
 // buffer of its own, so deciding whether a body is empty never copies the
 // output written before it.
 type writer struct {
-	bufs   []*strings.Builder
+	bufs   []*buffer
 	indent int
 	// holes are the gaps left for text written once the rest of the document is.
 	holes []hole
+	// marker writes the line closing a body whose members it lists were declared
+	// under made-up names, if any body is; nil writes none.
+	marker func(names []string) string
+}
+
+// buffer is the text of one open block and the names it declared that were
+// made up, to be marked before the block closes.
+type buffer struct {
+	strings.Builder
+	madeUp []string
 }
 
 // hole is a gap in the output: what fills it, at what indent, and the text once filled.
@@ -36,13 +46,12 @@ func (w *writer) hole(fill func()) {
 func (w *writer) fill() {
 	for i := range w.holes {
 		h := &w.holes[i]
-		w.bufs = append(w.bufs, &strings.Builder{})
+		w.bufs = append(w.bufs, &buffer{})
 		indent := w.indent
 		w.indent = h.indent
 		h.fill()
+		h.text = w.close()
 		w.indent = indent
-		h.text = w.bufs[len(w.bufs)-1].String()
-		w.bufs = w.bufs[:len(w.bufs)-1]
 	}
 }
 
@@ -66,15 +75,46 @@ func (w *writer) filled(out string) string {
 	}
 }
 
-func (w *writer) buf() *strings.Builder {
+func (w *writer) buf() *buffer {
 	if len(w.bufs) == 0 {
-		w.bufs = append(w.bufs, &strings.Builder{})
+		w.bufs = append(w.bufs, &buffer{})
 	}
 	return w.bufs[len(w.bufs)-1]
 }
 
-func (w *writer) line(s string) {
+// madeUp records that the block being written declared name for an element
+// its source left anonymous; the block is marked as it closes.
+func (w *writer) madeUp(name string) {
 	b := w.buf()
+	b.madeUp = append(b.madeUp, name)
+}
+
+// markMadeUp writes the marker for the names the open block made up so far, if
+// any, so that the block need not: for a body whose writer knows what the
+// marker may refer to as.
+func (w *writer) markMadeUp(marker func(names []string) string) {
+	b := w.buf()
+	if len(b.madeUp) == 0 {
+		return
+	}
+	names := b.madeUp
+	b.madeUp = nil
+	w.line(marker(names))
+}
+
+// close pops the innermost block, marking the names it made up that no body
+// marked, and returns its text.
+func (w *writer) close() string {
+	if w.marker != nil {
+		w.markMadeUp(w.marker)
+	}
+	b := w.bufs[len(w.bufs)-1]
+	w.bufs = w.bufs[:len(w.bufs)-1]
+	return b.String()
+}
+
+func (w *writer) line(s string) {
+	b := &w.buf().Builder
 	if s == "" {
 		b.WriteByte('\n')
 		return
@@ -127,12 +167,11 @@ func (w *writer) trailed(header, empty, lead string, body func()) {
 // capture renders what body writes, one level deeper, without writing it.
 func (w *writer) capture(body func()) string {
 	w.buf()
-	w.bufs = append(w.bufs, &strings.Builder{})
+	w.bufs = append(w.bufs, &buffer{})
 	w.indent++
 	body()
+	inner := w.close()
 	w.indent--
-	inner := w.bufs[len(w.bufs)-1].String()
-	w.bufs = w.bufs[:len(w.bufs)-1]
 	return inner
 }
 
@@ -143,4 +182,11 @@ func (w *writer) indented(body func()) {
 	w.indent--
 }
 
-func (w *writer) String() string { return w.filled(w.buf().String()) }
+// String is the document: the root block, marked for the names it made up
+// like any block, with every hole filled.
+func (w *writer) String() string {
+	if w.marker != nil {
+		w.markMadeUp(w.marker)
+	}
+	return w.filled(w.buf().String())
+}
diff --git a/internal/translate/migrate/writer_test.go b/internal/translate/migrate/writer_test.go
index 2642e1f45..3627bdf3c 100644
--- a/internal/translate/migrate/writer_test.go
+++ b/internal/translate/migrate/writer_test.go
@@ -2,6 +2,7 @@ package migrate
 
 import (
 	"runtime"
+	"strings"
 	"testing"
 )
 
@@ -73,3 +74,57 @@ func BenchmarkWriterSiblingBlocks(b *testing.B) {
 		}
 	}
 }
+
+// Each block marks the made-up names it declared as it closes, one marker line
+// per body: a nested block's names never leak to the block enclosing it, a
+// block marked early is not marked twice, and the root block is marked last.
+func TestWriterMarksMadeUpNamesPerBlock(t *testing.T) {
+	marker := func(names []string) string { return "metadata M about " + strings.Join(names, ", ") + ";" }
+	w := &writer{marker: marker}
+	w.block("part def A", func() {
+		w.line("part 'fork';")
+		w.madeUp("'fork'")
+		w.block("action def B", func() {
+			w.line("action final;")
+			w.madeUp("final")
+			w.line("action start;")
+			w.madeUp("start")
+		})
+		w.block("part def C", func() { w.line("attribute x;") })
+		w.line("part p;")
+		w.madeUp("p")
+	})
+	w.block("part def D", func() {
+		w.line("part q;")
+		w.madeUp("q")
+		w.markMadeUp(marker)
+		w.line("part r;")
+	})
+	w.line("part top;")
+	w.madeUp("top")
+	want := "part def A {\n" +
+		"    part 'fork';\n" +
+		"    action def B {\n        action final;\n        action start;\n        metadata M about final, start;\n    }\n" +
+		"    part def C {\n        attribute x;\n    }\n" +
+		"    part p;\n" +
+		"    metadata M about 'fork', p;\n}\n" +
+		"part def D {\n    part q;\n    metadata M about q;\n    part r;\n}\n" +
+		"part top;\nmetadata M about top;\n"
+	if got := w.String(); got != want {
+		t.Errorf("got\n%s\nwant\n%s", got, want)
+	}
+}
+
+// A block declaring no made-up names, and a writer with no marker, write none.
+func TestWriterMarksNothingWithoutMadeUpNames(t *testing.T) {
+	w := &writer{marker: func(names []string) string { return "metadata M about " + strings.Join(names, ", ") + ";" }}
+	w.block("part def A", func() { w.line("attribute x;") })
+	if got, want := w.String(), "part def A {\n    attribute x;\n}\n"; got != want {
+		t.Errorf("got\n%s\nwant\n%s", got, want)
+	}
+	unmarked := &writer{}
+	unmarked.block("part def A", func() { unmarked.line("part p;"); unmarked.madeUp("p") })
+	if got, want := unmarked.String(), "part def A {\n    part p;\n}\n"; got != want {
+		t.Errorf("got\n%s\nwant\n%s", got, want)
+	}
+}
diff --git a/internal/workspace/libs/stdlib.snapshot b/internal/workspace/libs/stdlib.snapshot
index a550b8134..3b61e0bc3 100644
Binary files a/internal/workspace/libs/stdlib.snapshot and b/internal/workspace/libs/stdlib.snapshot differ
diff --git a/internal/workspace/libs/stdlib/OpenSysML Libraries/MigrationMetadata.sysml b/internal/workspace/libs/stdlib/OpenSysML Libraries/MigrationMetadata.sysml
new file mode 100644
index 000000000..3681b1377
--- /dev/null
+++ b/internal/workspace/libs/stdlib/OpenSysML Libraries/MigrationMetadata.sysml	
@@ -0,0 +1,11 @@
+standard library package MigrationMetadata {
+    doc /* What a migration from another modeling language had to make up
+         * because its source left it unstated. Non-normative OpenSysML
+         * extension, proposed for standardization; see the design record. */
+
+    metadata def SynthesizedName {
+        doc /* The annotated element was anonymous in the source; the
+             * migration named it so the notation could declare and refer to
+             * it. The name keys the element but is not one a picture shows. */
+    }
+}
diff --git a/packaging/man/man1/sysml.1 b/packaging/man/man1/sysml.1
index 703c69718..ba7d59d29 100644
--- a/packaging/man/man1/sysml.1
+++ b/packaging/man/man1/sysml.1
@@ -253,6 +253,11 @@ for \-render\-all
 Palette the dot or plantuml form fills nodes from, by keyword family:
 okabe\-ito, tol\-bright, tol\-muted, tol\-light, brewer\-set2, brewer\-dark2,
 viridis or cividis; default black and white
+.TP
+.BR \-render\-unplaced " \fIplacement\fP"
+Where the dot form of a view some Layout positions puts the nodes none does:
+omit (default) leaves them undrawn, strip draws them in rows below the
+drawing; applies to \-render, \-render\-all and document diagrams
 .SS Rendering documents
 .TP
 .BR \-render\-document " \fIname\fP"
@@ -751,6 +756,9 @@ sysml model.sysml \-render Views::vehicleView \-o view.mmd
 sysml model.sysml \-render Views::vehicleView \-render\-form dot
 sysml model.sysml \-render Views::vehicleView \-render\-form dot \e
     \-render\-palette okabe\-ito
+# unpositioned nodes in a strip below
+sysml model.sysml \-render Views::vehicleView \-render\-form dot \e
+    \-render\-unplaced strip
 sysml model.sysml \-render Views::vehicleView \-render\-form plantuml \-o \e
     view.puml
 # several files, loaded as one model
@@ -776,7 +784,12 @@ neither Graphviz nor PlantUML is needed to write them. Both are drawn in the
 black\-and\-white style of the SysML v2 Pilot visualizer; \-render\-palette
 fills their nodes by keyword family from a colourblind\-safe palette
 (okabe\-ito, tol\-bright, tol\-muted, tol\-light, brewer\-set2, brewer\-dark2,
-viridis or cividis), keeping black text legible on every fill.
+viridis or cividis), keeping black text legible on every fill. A DOT drawing
+of a view whose members carry DiagramLayout positions pins each at its stated
+place and leaves a member with no position undrawn, so nothing lands on a
+positioned box; \-render\-unplaced strip draws those members instead, in rows
+in a strip below the drawing. The same setting shapes the DOT diagrams of
+\-render\-document and \-render\-documents.
 .SH RENDERING A DOCUMENT
 .RS 2
 .nf
diff --git a/tests/migrate/layout_test.go b/tests/migrate/layout_test.go
index e5cb6a6bc..49fe0279d 100644
--- a/tests/migrate/layout_test.go
+++ b/tests/migrate/layout_test.go
@@ -182,12 +182,19 @@ func TestGoldenControlNodeLayout(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	for _, unwanted := range []string{`xlabel="'fork'"`, `xlabel="final"`, "'start to fork'", "«initial»", "«final»"} {
+		if strings.Contains(dot, unwanted) {
+			t.Errorf("DOT of the activity view draws the name %s the migration made up:\n%s", unwanted, dot)
+		}
+	}
 	for _, want := range []string{
 		"// layout: neato -n2\n",
-		`<i>«fork»</i></font>>, pos="100,217!", pin=true, width=1.6666666666666667, height=0.08333333333333333, fixedsize=true];`,
-		`<i>«initial»</i></font>>, pos="100,290!", pin=true, width=1.1111111111111112, height=1.1111111111111112];`,
-		`<i>«final»</i></font>>, pos="150,-14.5!", pin=true, width=0.9583333333333334, height=0.9583333333333334];`,
-		`"n9" -> "n1" [label="'start to fork'", pos="100,250 100,250 100,220 100,220"];`,
+		`"n1" [fillcolor=black, label="", pos="100,217!", pin=true, width=1.6666666666666667, height=0.08333333333333333, fixedsize=true];`,
+		`"n7" [shape=diamond, label="", xlabel="check", pos="100,70!", pin=true, width=0.2777777777777778, height=0.2777777777777778, fixedsize=true];`,
+		`"n8" [shape=doublecircle, fillcolor=black, label="", pos="50,10!", pin=true, width=0.2777777777777778, height=0.2777777777777778, fixedsize=true];`,
+		`"n9" [shape=circle, fillcolor=black, label="", pos="100,257.2!", pin=true, width=0.2, height=0.2];`,
+		`"n10" [shape=doublecircle, fillcolor=black, label="", pos="150,12.8`,
+		`"n9" -> "n1" [pos="100,250 100,250 100,220 100,220"];`,
 		`"n7" -> "n10" [label="[false]", pos="110,70 110,70 150,70 150,70 150,70 150,20 150,20"];`,
 	} {
 		if !strings.Contains(dot, want) {
@@ -197,13 +204,14 @@ func TestGoldenControlNodeLayout(t *testing.T) {
 }
 
 // The routes a migrated view carries reach the DOT form as pinned edge splines for each
-// edge kind, labelled by name only where the edge has no text of its own.
+// edge kind, labelled by name only where the edge has no text of its own and the name is
+// the source's: one the migration made up, and marked, labels nothing.
 func TestMigratedRoutesRenderPinned(t *testing.T) {
 	r := migrateLaidOut(t, "diagram_edges")
 	s := session(t, r)
 	for view, wants := range map[string][]string{
 		"Structure::Vehicle::Drive::Driving": {
-			`"n5" -> "n1" [label="'start to gain'", pos="60,180 60,180 60,210 60,210"];`,
+			`"n5" -> "n1" [pos="60,180 60,180 60,210 60,210"];`,
 			`"n3" -> "n4" [label="finish", pos="60,20 60,20 60,60 60,60"];`,
 			`[label="result to value", style=dashed, pos="110,80 110,80 140,80 140,80 140,80 140,160 140,160 140,160 110,160 110,160"];`,
 		},
@@ -214,10 +222,10 @@ func TestMigratedRoutesRenderPinned(t *testing.T) {
 			`"n3" -> "n2" [label="accept Resume", pos="280,90 280,90 320,90 320,90 320,90 320,40 320,40 320,40 280,40 280,40"];`,
 		},
 		"Structure::Vehicle::'Vehicle Internals'": {
-			`[label="'engine to wheel'", arrowhead=none, penwidth=3, pos="200,100 200,100 120,100 120,100"];`,
-			`[label="'engine to wheel 2'", arrowhead=none, penwidth=3, pos="200,80 200,80 160,60 160,60 160,60 120,80 120,80"];`,
+			`[label="connection", arrowhead=none, penwidth=3, pos="200,100 200,100 120,100 120,100"];`,
+			`[label="connection", arrowhead=none, penwidth=3, pos="200,80 200,80 160,60 160,60 160,60 120,80 120,80"];`,
 			`[label="drive", arrowhead=none, penwidth=3, pos="200,90 200,90 120,90 120,90"];`,
-			`[label="'mass = limit'", arrowhead=none, pos="200,10 200,10 120,10 120,10"];`,
+			`[label="binding", arrowhead=none, pos="200,10 200,10 120,10 120,10"];`,
 		},
 	} {
 		rendering, err := s.ViewRendering(view)
diff --git a/tests/migrate/testdata/xmi/acquisition.golden.sysml b/tests/migrate/testdata/xmi/acquisition.golden.sysml
index ccc59d24b..e2f956068 100644
--- a/tests/migrate/testdata/xmi/acquisition.golden.sysml
+++ b/tests/migrate/testdata/xmi/acquisition.golden.sysml
@@ -162,5 +162,6 @@ part def Observatory {
         first stamp10 then final;
         action final terminate;
         /* partition 'Telescope Control' represents Observatory::tcs: seed, first attempt, attempt, decide, guide star found, next attempt, abort */
+        metadata MigrationMetadata::SynthesizedName about stamp9, stamp, stamp3, 'merge', wait, stamp5, stamp6, 'fork', stamp11, merge2, stamp12, merge3, 'decide', stamp4, stamp2, stamp7, stamp8, fork2, merge4, stamp10, final;
     }
 }
diff --git a/tests/migrate/testdata/xmi/bundled_library.golden.sysml b/tests/migrate/testdata/xmi/bundled_library.golden.sysml
index 0ec81071a..a8f0d2d19 100644
--- a/tests/migrate/testdata/xmi/bundled_library.golden.sysml
+++ b/tests/migrate/testdata/xmi/bundled_library.golden.sysml
@@ -43,5 +43,6 @@ part def Recorder {
         flow label.result to size.list;
         flow label.result to get.list;
         flow get.result to print.value;
+        metadata MigrationMetadata::SynthesizedName about 'fork', 'join', final;
     }
 }
diff --git a/tests/migrate/testdata/xmi/collectors.golden.sysml b/tests/migrate/testdata/xmi/collectors.golden.sysml
index 8ab68b4ba..ede13d13c 100644
--- a/tests/migrate/testdata/xmi/collectors.golden.sysml
+++ b/tests/migrate/testdata/xmi/collectors.golden.sysml
@@ -88,6 +88,7 @@ package Drafts {
             render Views::asTreeDiagram;
         }
     }
+    metadata MigrationMetadata::SynthesizedName about unnamed;
 }
 package 'Yard Viewpoints' {
     viewpoint 'Block Diagrams Viewpoint' {
@@ -98,6 +99,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'block Diagrams Method' : 'Block Diagrams Method';
     }
@@ -109,6 +111,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'all Diagrams Method' : 'All Diagrams Method';
     }
@@ -120,6 +123,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'no Diagrams Method' : 'No Diagrams Method';
     }
@@ -138,6 +142,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about 'fork', 'merge', final;
         }
         perform action 'sketched Diagrams Method' : 'Sketched Diagrams Method';
     }
@@ -158,6 +163,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about 'fork', 'merge', final;
         }
         perform action 'retargeted Diagrams Method' : 'Retargeted Diagrams Method';
     }
@@ -171,6 +177,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'kin Diagrams Method' : 'Kin Diagrams Method';
     }
@@ -182,6 +189,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'other Diagrams Method' : 'Other Diagrams Method';
     }
@@ -195,6 +203,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'internal Diagrams Method' : 'Internal Diagrams Method';
     }
@@ -206,6 +215,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'parametric Diagrams Method' : 'Parametric Diagrams Method';
     }
@@ -224,6 +234,7 @@ package 'Yard Viewpoints' {
             }
             first 'Shown Blocks' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'shown Method' : 'Shown Method';
     }
@@ -238,6 +249,7 @@ package 'Yard Viewpoints' {
             }
             first 'Shown Everywhere' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'shown Everywhere Method' : 'Shown Everywhere Method';
     }
@@ -249,6 +261,7 @@ package 'Yard Viewpoints' {
             action 'Drive Parts';
             first 'Drive Parts' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'drive Parts Method' : 'Drive Parts Method';
     }
@@ -260,6 +273,7 @@ package 'Yard Viewpoints' {
             action Parts;
             first Parts then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'parts Method' : 'Parts Method';
     }
@@ -271,6 +285,7 @@ package 'Yard Viewpoints' {
             action 'Direct Parts';
             first 'Direct Parts' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'direct Parts Method' : 'Direct Parts Method';
     }
@@ -282,6 +297,7 @@ package 'Yard Viewpoints' {
             action 'Shared Parts';
             first 'Shared Parts' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'shared Parts Method' : 'Shared Parts Method';
     }
@@ -298,6 +314,7 @@ package 'Yard Viewpoints' {
             }
             first 'To Do Items' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'to Do Method' : 'To Do Method';
     }
@@ -313,6 +330,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'documented Diagrams Method' : 'Documented Diagrams Method';
     }
@@ -326,6 +344,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'reverse Documented Diagrams Method' : 'Reverse Documented Diagrams Method';
     }
@@ -337,6 +356,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'diagrams By Documentation Method' : 'Diagrams By Documentation Method';
     }
@@ -354,6 +374,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'unnamed Drafts Method' : 'Unnamed Drafts Method';
     }
@@ -371,6 +392,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'optional Drafts Method' : 'Optional Drafts Method';
     }
@@ -382,6 +404,7 @@ package 'Yard Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'owner Sorted Diagrams Method' : 'Owner Sorted Diagrams Method';
     }
@@ -402,6 +425,7 @@ package 'Yard Viewpoints' {
             }
             first 'Requirements Specification Table' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'specification Method' : 'Specification Method';
     }
diff --git a/tests/migrate/testdata/xmi/control_nodes.golden.sysml b/tests/migrate/testdata/xmi/control_nodes.golden.sysml
index 3c45431f9..38a8ee027 100644
--- a/tests/migrate/testdata/xmi/control_nodes.golden.sysml
+++ b/tests/migrate/testdata/xmi/control_nodes.golden.sysml
@@ -23,6 +23,7 @@ package Control {
             succession 'check to final' first check then final;
             succession 'check to done' first check if false then done;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about 'start to fork', 'fork', 'fork to heat', 'fork to cool', 'heat to join', 'cool to join', 'join', 'join to check', 'check to final', 'check to done', final;
         }
     }
 }
diff --git a/tests/migrate/testdata/xmi/control_nodes.layout.golden.sysml b/tests/migrate/testdata/xmi/control_nodes.layout.golden.sysml
index 40793ac52..b986a0f31 100644
--- a/tests/migrate/testdata/xmi/control_nodes.layout.golden.sysml
+++ b/tests/migrate/testdata/xmi/control_nodes.layout.golden.sysml
@@ -38,6 +38,7 @@ package Control {
             succession 'check to final' first check then final;
             succession 'check to done' first check if false then done;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about 'start to fork', 'fork', 'fork to heat', 'fork to cool', 'heat to join', 'cool to join', 'join', 'join to check', 'check to final', 'check to done', final;
         }
     }
 }
diff --git a/tests/migrate/testdata/xmi/diagram_edges.golden.sysml b/tests/migrate/testdata/xmi/diagram_edges.golden.sysml
index bdf8d0c84..35db63241 100644
--- a/tests/migrate/testdata/xmi/diagram_edges.golden.sysml
+++ b/tests/migrate/testdata/xmi/diagram_edges.golden.sysml
@@ -34,6 +34,7 @@ package Structure {
             action final terminate;
             flow 'gain.result to set speed.value' from gain.result to 'set speed'.value;
             binding 'set speed.value = target' bind 'set speed'.value = target;
+            metadata MigrationMetadata::SynthesizedName about 'start to gain', final, 'gain.result to set speed.value', 'set speed.value = target';
         }
         satisfy requirement 'satisfy Mass Limit' : Requirements::'Mass Limit';
         satisfy requirement : Requirements::'Speed Limit';
@@ -49,9 +50,11 @@ package Structure {
             expose 'mass = limit';
             render Views::asInterconnectionDiagram;
         }
+        metadata MigrationMetadata::SynthesizedName about 'engine to wheel', 'engine to wheel 2', 'mass = limit', 'satisfy Mass Limit', 'satisfy Speed Limit';
     }
     part def Engine :> Component {
         satisfy requirement 'satisfy Speed Limit' : Requirements::'Speed Limit';
+        metadata MigrationMetadata::SynthesizedName about 'satisfy Speed Limit';
     }
     part def Wheel;
     dependency 'Vehicle to Engine' from Vehicle to Engine;
@@ -68,6 +71,7 @@ package Structure {
         expose 'Wheel to Component';
         render Views::asTreeDiagram;
     }
+    metadata MigrationMetadata::SynthesizedName about 'Vehicle to Engine', 'Engine to Component', 'Wheel to Component';
 }
 package Behavior {
     item def Go;
@@ -93,6 +97,7 @@ package Behavior {
         transition first Halted then Idle;
         transition 'Halted accept Go then Running' first Halted accept Go then Running;
         transition 'Halted accept Resume then Running' first Halted accept Resume then Running;
+        metadata MigrationMetadata::SynthesizedName about 'Idle accept Go then Running', 'Halted accept Go then Running', 'Halted accept Resume then Running';
     }
 }
 package Requirements {
@@ -105,7 +110,9 @@ package Requirements {
     verification def 'Mass Test' {
         objective 'objective' {
             verify requirement 'verify Mass Limit' : 'Mass Limit';
+            metadata MigrationMetadata::SynthesizedName about 'verify Mass Limit';
         }
+        metadata MigrationMetadata::SynthesizedName about 'objective';
     }
     view Traceability {
         expose 'Mass Limit';
@@ -122,6 +129,7 @@ package Usage {
     use case def 'Drive Vehicle' {
         include use case 'start Engine' : 'Start Engine';
         include use case 'stop Engine' : 'Stop Engine';
+        metadata MigrationMetadata::SynthesizedName about 'start Engine', 'stop Engine';
     }
     use case def 'Start Engine';
     use case def 'Stop Engine';
diff --git a/tests/migrate/testdata/xmi/diagram_edges.layout.golden.sysml b/tests/migrate/testdata/xmi/diagram_edges.layout.golden.sysml
index 32072926d..52112842d 100644
--- a/tests/migrate/testdata/xmi/diagram_edges.layout.golden.sysml
+++ b/tests/migrate/testdata/xmi/diagram_edges.layout.golden.sysml
@@ -41,6 +41,7 @@ package Structure {
             action final terminate;
             flow 'gain.result to set speed.value' from gain.result to 'set speed'.value;
             binding 'set speed.value = target' bind 'set speed'.value = target;
+            metadata MigrationMetadata::SynthesizedName about 'start to gain', final, 'gain.result to set speed.value', 'set speed.value = target';
         }
         satisfy requirement 'satisfy Mass Limit' : Requirements::'Mass Limit';
         satisfy requirement : Requirements::'Speed Limit';
@@ -65,9 +66,11 @@ package Structure {
             metadata DiagramLayout::Route about 'mass = limit' { points = (200, 110, 120, 110); }
             render Views::asInterconnectionDiagram;
         }
+        metadata MigrationMetadata::SynthesizedName about 'engine to wheel', 'engine to wheel 2', 'mass = limit', 'satisfy Mass Limit', 'satisfy Speed Limit';
     }
     part def Engine :> Component {
         satisfy requirement 'satisfy Speed Limit' : Requirements::'Speed Limit';
+        metadata MigrationMetadata::SynthesizedName about 'satisfy Speed Limit';
     }
     part def Wheel;
     dependency 'Vehicle to Engine' from Vehicle to Engine;
@@ -89,6 +92,7 @@ package Structure {
         metadata DiagramLayout::Layout about Wheel { x = 230; y = 160; width = 100; height = 80; }
         render Views::asTreeDiagram;
     }
+    metadata MigrationMetadata::SynthesizedName about 'Vehicle to Engine', 'Engine to Component', 'Wheel to Component';
 }
 package Behavior {
     item def Go;
@@ -121,6 +125,7 @@ package Behavior {
         transition first Halted then Idle;
         transition 'Halted accept Go then Running' first Halted accept Go then Running;
         transition 'Halted accept Resume then Running' first Halted accept Resume then Running;
+        metadata MigrationMetadata::SynthesizedName about 'Idle accept Go then Running', 'Halted accept Go then Running', 'Halted accept Resume then Running';
     }
 }
 package Requirements {
@@ -133,7 +138,9 @@ package Requirements {
     verification def 'Mass Test' {
         objective 'objective' {
             verify requirement 'verify Mass Limit' : 'Mass Limit';
+            metadata MigrationMetadata::SynthesizedName about 'verify Mass Limit';
         }
+        metadata MigrationMetadata::SynthesizedName about 'objective';
     }
     view Traceability {
         expose 'Mass Limit';
@@ -154,6 +161,7 @@ package Usage {
     use case def 'Drive Vehicle' {
         include use case 'start Engine' : 'Start Engine';
         include use case 'stop Engine' : 'Stop Engine';
+        metadata MigrationMetadata::SynthesizedName about 'start Engine', 'stop Engine';
     }
     use case def 'Start Engine';
     use case def 'Stop Engine';
diff --git a/tests/migrate/testdata/xmi/diagrams.golden.sysml b/tests/migrate/testdata/xmi/diagrams.golden.sysml
index 6a15198bd..1f35ce50a 100644
--- a/tests/migrate/testdata/xmi/diagrams.golden.sysml
+++ b/tests/migrate/testdata/xmi/diagrams.golden.sysml
@@ -17,6 +17,7 @@ package Structure {
             expose Engine;
             render Views::asElementTable;
         }
+        metadata MigrationMetadata::SynthesizedName about 'engine to wheel';
     }
     part def Engine {
         attribute power : ScalarValues::Real;
@@ -38,6 +39,7 @@ package Structure {
             }
             succession 'ignite to final' first ignite then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about 'start to ignite', 'ignite to final', final;
         }
         action crank : Crank;
         action def Halt {
@@ -51,6 +53,7 @@ package Structure {
              */
         }
         action halt : Halt;
+        metadata MigrationMetadata::SynthesizedName about wheel;
     }
     part def Wheel;
     view 'Vehicle Structure' {
@@ -93,6 +96,7 @@ package Behavior {
         }
         succession 'start engine to final' first 'start engine' then final;
         action final terminate;
+        metadata MigrationMetadata::SynthesizedName about 'start to start engine', 'start engine to final', final;
     }
     state def Modes {
         view 'Idle 2' : StandardViewDefinitions::StateTransitionView {
@@ -103,6 +107,7 @@ package Behavior {
         state Idle;
         state Running;
         transition 'Idle then Running' first Idle then Running;
+        metadata MigrationMetadata::SynthesizedName about 'Idle then Running';
     }
 }
 package Usage {
diff --git a/tests/migrate/testdata/xmi/documents.golden.sysml b/tests/migrate/testdata/xmi/documents.golden.sysml
index 4b7926a87..37cd48b4d 100644
--- a/tests/migrate/testdata/xmi/documents.golden.sysml
+++ b/tests/migrate/testdata/xmi/documents.golden.sysml
@@ -77,6 +77,7 @@ package 'Fleet Viewpoints' {
             first 'Fleet Parts' then final;
             action final terminate;
             flow 'Collect Owned Elements'.result to 'Filter By Metaclasses'.input;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'parts Method' : 'Parts Method';
     }
@@ -99,6 +100,7 @@ package 'Fleet Viewpoints' {
             action 'Requirement Texts';
             first 'Requirement Texts' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
     }
     viewpoint 'Safety Viewpoint' {
@@ -123,6 +125,7 @@ package 'Fleet Viewpoints' {
             }
             first 'Safety Requirements' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
     }
     viewpoint 'Figures Viewpoint' {
@@ -131,6 +134,7 @@ package 'Fleet Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'figures Method' : 'Figures Method';
     }
@@ -140,6 +144,7 @@ package 'Fleet Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'gallery Method' : 'Gallery Method';
     }
@@ -153,6 +158,7 @@ package 'Fleet Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'selected Figures Method' : 'Selected Figures Method';
     }
@@ -164,6 +170,7 @@ package 'Fleet Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'other Figures Method' : 'Other Figures Method';
     }
@@ -177,6 +184,7 @@ package 'Fleet Viewpoints' {
             action List;
             first List then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'figure Owners Method' : 'Figure Owners Method';
     }
@@ -188,6 +196,7 @@ package 'Fleet Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'no Figures Method' : 'No Figures Method';
     }
@@ -206,6 +215,7 @@ package 'Fleet Viewpoints' {
             action 'Related Elements';
             first 'Related Elements' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about 'fork', 'merge', final;
         }
         perform action 'traceability Method' : 'Traceability Method';
     }
@@ -232,6 +242,7 @@ package 'Fleet Viewpoints' {
             }
             first 'Missing Behavior' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         action def 'Per Truck' {
             first start then Paragraph;
@@ -241,6 +252,7 @@ package 'Fleet Viewpoints' {
             first 'Per Truck Again' then final;
             action final terminate;
             /* applied stereotype «Dynamic_View»: loop = true; title = Per Truck */
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'oddities Method' : 'Oddities Method';
     }
@@ -250,6 +262,7 @@ package 'Fleet Viewpoints' {
             action Paragraph;
             first Paragraph then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'broken Method' : 'Broken Method';
     }
diff --git a/tests/migrate/testdata/xmi/empty_behaviors.golden.sysml b/tests/migrate/testdata/xmi/empty_behaviors.golden.sysml
index 086356b2d..760109598 100644
--- a/tests/migrate/testdata/xmi/empty_behaviors.golden.sysml
+++ b/tests/migrate/testdata/xmi/empty_behaviors.golden.sysml
@@ -36,6 +36,7 @@ part def Gate {
                 action 'drop log' {
                     /* not migrated: DestroyObjectAction 'drop log' — no v2 form for a UML DestroyObjectAction */
                 }
+                metadata MigrationMetadata::SynthesizedName about 'fork';
             }
             do action poll {
                 /* body not migrated (the statement "CALL POLL(count)" is not an assignment of a v2 expression (language Fortran)) {Fortran}:
diff --git a/tests/migrate/testdata/xmi/figures.golden.sysml b/tests/migrate/testdata/xmi/figures.golden.sysml
index 8fb5445e3..85e32ce0f 100644
--- a/tests/migrate/testdata/xmi/figures.golden.sysml
+++ b/tests/migrate/testdata/xmi/figures.golden.sysml
@@ -11,6 +11,7 @@ package Plant {
             state Idle;
             state Running;
             transition 'Idle accept Start then Running' first Idle accept Start then Running;
+            metadata MigrationMetadata::SynthesizedName about 'Idle accept Start then Running';
         }
         action def Prime {
             view Priming : StandardViewDefinitions::ActionFlowView {
@@ -27,6 +28,7 @@ package Plant {
             }
             first Vent then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
     }
     part def Tank;
@@ -58,6 +60,7 @@ package 'Plant Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'figures Method' : 'Figures Method';
     }
@@ -67,6 +70,7 @@ package 'Plant Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'pictures Method' : 'Pictures Method';
     }
@@ -81,6 +85,7 @@ package 'Plant Viewpoints' {
             }
             first 'Shown Blocks' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'shown Method' : 'Shown Method';
     }
diff --git a/tests/migrate/testdata/xmi/figures.mdzip.golden.sysml b/tests/migrate/testdata/xmi/figures.mdzip.golden.sysml
index cbe5be4ad..47f63dd0e 100644
--- a/tests/migrate/testdata/xmi/figures.mdzip.golden.sysml
+++ b/tests/migrate/testdata/xmi/figures.mdzip.golden.sysml
@@ -11,6 +11,7 @@ package Plant {
             state Idle;
             state Running;
             transition 'Idle accept Start then Running' first Idle accept Start then Running;
+            metadata MigrationMetadata::SynthesizedName about 'Idle accept Start then Running';
         }
         action def Prime {
             view Priming : StandardViewDefinitions::ActionFlowView {
@@ -27,6 +28,7 @@ package Plant {
             }
             first Vent then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
     }
     part def Tank;
@@ -61,6 +63,7 @@ package 'Plant Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'figures Method' : 'Figures Method';
     }
@@ -70,6 +73,7 @@ package 'Plant Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'pictures Method' : 'Pictures Method';
     }
@@ -84,6 +88,7 @@ package 'Plant Viewpoints' {
             }
             first 'Shown Blocks' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'shown Method' : 'Shown Method';
     }
diff --git a/tests/migrate/testdata/xmi/heater_receptions.golden.sysml b/tests/migrate/testdata/xmi/heater_receptions.golden.sysml
index 58cbd039b..e2b52516d 100644
--- a/tests/migrate/testdata/xmi/heater_receptions.golden.sysml
+++ b/tests/migrate/testdata/xmi/heater_receptions.golden.sysml
@@ -150,6 +150,7 @@ part def Thermostat {
         first 'send stop' then final;
         action final terminate;
         flow seven.result to 'send level'.value;
+        metadata MigrationMetadata::SynthesizedName about final;
     }
 }
 part def Room {
diff --git a/tests/migrate/testdata/xmi/layout.golden.sysml b/tests/migrate/testdata/xmi/layout.golden.sysml
index 53d641b4f..f7c5cba1b 100644
--- a/tests/migrate/testdata/xmi/layout.golden.sysml
+++ b/tests/migrate/testdata/xmi/layout.golden.sysml
@@ -32,5 +32,6 @@ package Behavior {
              * going = true;
              */
         }
+        metadata MigrationMetadata::SynthesizedName about 'start to step';
     }
 }
diff --git a/tests/migrate/testdata/xmi/layout.layout.golden.sysml b/tests/migrate/testdata/xmi/layout.layout.golden.sysml
index 2692c29c3..2caab876d 100644
--- a/tests/migrate/testdata/xmi/layout.layout.golden.sysml
+++ b/tests/migrate/testdata/xmi/layout.layout.golden.sysml
@@ -40,5 +40,6 @@ package Behavior {
              * going = true;
              */
         }
+        metadata MigrationMetadata::SynthesizedName about 'start to step';
     }
 }
diff --git a/tests/migrate/testdata/xmi/library_calls.golden.sysml b/tests/migrate/testdata/xmi/library_calls.golden.sysml
index 307542db1..6ada64c03 100644
--- a/tests/migrate/testdata/xmi/library_calls.golden.sysml
+++ b/tests/migrate/testdata/xmi/library_calls.golden.sysml
@@ -76,5 +76,6 @@ part def Recorder {
         flow second.result to position.seq;
         /* flow position.result to 'after'.x not written: 'position' is not migrated and produces no value */
         flow concat.result to print.value;
+        metadata MigrationMetadata::SynthesizedName about 'fork', fork2, 'join', join2, final;
     }
 }
diff --git a/tests/migrate/testdata/xmi/meter.golden.sysml b/tests/migrate/testdata/xmi/meter.golden.sysml
index f3721990c..ad5790964 100644
--- a/tests/migrate/testdata/xmi/meter.golden.sysml
+++ b/tests/migrate/testdata/xmi/meter.golden.sysml
@@ -7,6 +7,7 @@ part def Gauge {
     action def Tick {
         first start then final;
         action final terminate;
+        metadata MigrationMetadata::SynthesizedName about final;
     }
 }
 part def Needle :> Gauge;
@@ -97,6 +98,7 @@ part def Meter {
         first shout then final;
         action final terminate;
         flow sense.y to record.v;
+        metadata MigrationMetadata::SynthesizedName about final;
     }
     action def Skip {
         first start then idle;
@@ -125,6 +127,7 @@ part def Meter {
         action final terminate;
         /* flow idle.z to sink.w not written: the body of 'idle' never assigns idle.z */
         /* flow dark.q to drain.w not written: 'dark' is not migrated and produces no value */
+        metadata MigrationMetadata::SynthesizedName about final;
     }
     action def Flip {
         first start then bump;
@@ -178,6 +181,7 @@ part def Meter {
         }
         first 'alias' then final;
         action final terminate;
+        metadata MigrationMetadata::SynthesizedName about final;
     }
     action def Arm {
         in armed : ScalarValues::Boolean {
@@ -197,6 +201,7 @@ part def Meter {
         }
         first latch then final;
         action final terminate;
+        metadata MigrationMetadata::SynthesizedName about final;
     }
     action def Sweep {
         first start then spread;
@@ -252,5 +257,6 @@ part def Meter {
         /* partition 'cells' represents Meter::cells: calib, span, ticking */
         /* partition 'banks' represents Meter::banks: charge */
         /* partition 'bank' represents Bank: settle */
+        metadata MigrationMetadata::SynthesizedName about final;
     }
 }
diff --git a/tests/migrate/testdata/xmi/montecarlo.golden.sysml b/tests/migrate/testdata/xmi/montecarlo.golden.sysml
index c1247a046..e386e6177 100644
--- a/tests/migrate/testdata/xmi/montecarlo.golden.sysml
+++ b/tests/migrate/testdata/xmi/montecarlo.golden.sysml
@@ -15,6 +15,7 @@ part def Timer {
         first 'set t' then final;
         action final terminate;
         flow three.result to 'set t'.value;
+        metadata MigrationMetadata::SynthesizedName about final;
     }
     perform action tick : Tick;
 }
diff --git a/tests/migrate/testdata/xmi/montecarlo_case.golden.sysml b/tests/migrate/testdata/xmi/montecarlo_case.golden.sysml
index e06502f59..8f8dcadf5 100644
--- a/tests/migrate/testdata/xmi/montecarlo_case.golden.sysml
+++ b/tests/migrate/testdata/xmi/montecarlo_case.golden.sysml
@@ -19,6 +19,7 @@ part def Sensor {
         }
         first 'stop timer' then final;
         action final terminate;
+        metadata MigrationMetadata::SynthesizedName about wait, final;
     }
     perform action settle : Settle;
 }
diff --git a/tests/migrate/testdata/xmi/parking_usecases.golden.sysml b/tests/migrate/testdata/xmi/parking_usecases.golden.sysml
index 73845e30b..fdb21ebbb 100644
--- a/tests/migrate/testdata/xmi/parking_usecases.golden.sysml
+++ b/tests/migrate/testdata/xmi/parking_usecases.golden.sysml
@@ -20,10 +20,12 @@ package 'Use Cases' {
             }
             first Enter then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         actor driver : Context::Driver;
         actor attendant : Context::Attendant[0..1];
         perform action 'park Flow' : 'Park Flow';
+        metadata MigrationMetadata::SynthesizedName about garage, 'pay Fee';
     }
     use case def 'Pay Fee' {
         subject garage : Context::Garage;
@@ -31,6 +33,7 @@ package 'Use Cases' {
         include use case authorise : 'Authorise Payment';
         attribute amount : Real;
         actor bank : Context::Bank;
+        metadata MigrationMetadata::SynthesizedName about garage, ticket;
     }
     use case def 'Authorise Payment' {
         subject;
@@ -51,10 +54,13 @@ package 'Use Cases' {
     connection def Settlement {
         end bank : Context::Bank;
         end 'pay Fee' : 'Pay Fee';
+        metadata MigrationMetadata::SynthesizedName about 'pay Fee';
     }
     connection def unnamed {
         end 'park Car' : 'Park Car';
         end 'wait For Space' : 'Wait For Space';
+        metadata MigrationMetadata::SynthesizedName about 'park Car', 'wait For Space';
     }
+    metadata MigrationMetadata::SynthesizedName about unnamed;
 }
 attribute def Real;
diff --git a/tests/migrate/testdata/xmi/plant.golden.sysml b/tests/migrate/testdata/xmi/plant.golden.sysml
index 7e1c71bdf..e50aad871 100644
--- a/tests/migrate/testdata/xmi/plant.golden.sysml
+++ b/tests/migrate/testdata/xmi/plant.golden.sysml
@@ -96,5 +96,6 @@ part def Plant {
         /* partition 'Pump' represents Plant::pump: torn, prime */
         /* partition 'Controller' represents Controller: arm */
         /* partition 'Led' represents Controller::led: light */
+        metadata MigrationMetadata::SynthesizedName about final;
     }
 }
diff --git a/tests/migrate/testdata/xmi/plant_states.golden.sysml b/tests/migrate/testdata/xmi/plant_states.golden.sysml
index 5b2461b83..1a0c27bd2 100644
--- a/tests/migrate/testdata/xmi/plant_states.golden.sysml
+++ b/tests/migrate/testdata/xmi/plant_states.golden.sysml
@@ -50,6 +50,7 @@ part def Plant {
                 }
             }
             transition first regions then done;
+            metadata MigrationMetadata::SynthesizedName about regions;
         }
         transition first Idle accept Go then Work;
         transition first Work::Run accept Stop then Idle;
diff --git a/tests/migrate/testdata/xmi/ported_calls.golden.sysml b/tests/migrate/testdata/xmi/ported_calls.golden.sysml
index cc3ed53f6..a9080c4db 100644
--- a/tests/migrate/testdata/xmi/ported_calls.golden.sysml
+++ b/tests/migrate/testdata/xmi/ported_calls.golden.sysml
@@ -48,6 +48,7 @@ part def Drive {
         action final terminate;
         flow thirty.result to 'spin over p'.rpm;
         flow forty.result to 'spin over cmd'.rpm;
+        metadata MigrationMetadata::SynthesizedName about 'fork', 'join', final;
     }
     action def Stray {
         first start then 'fork';
@@ -66,5 +67,6 @@ part def Drive {
         action 'spin over split' : Motor::Spin;
         flow five.result to 'spin over loose'.rpm;
         flow six.result to 'spin over split'.rpm;
+        metadata MigrationMetadata::SynthesizedName about 'fork';
     }
 }
diff --git a/tests/migrate/testdata/xmi/reactor.golden.sysml b/tests/migrate/testdata/xmi/reactor.golden.sysml
index fddb7a4fd..89065b295 100644
--- a/tests/migrate/testdata/xmi/reactor.golden.sysml
+++ b/tests/migrate/testdata/xmi/reactor.golden.sysml
@@ -169,5 +169,6 @@ part def Reactor {
         }
         first bare then final;
         action final terminate;
+        metadata MigrationMetadata::SynthesizedName about final;
     }
 }
diff --git a/tests/migrate/testdata/xmi/report_views.golden.sysml b/tests/migrate/testdata/xmi/report_views.golden.sysml
index 02cb09983..00a8721ed 100644
--- a/tests/migrate/testdata/xmi/report_views.golden.sysml
+++ b/tests/migrate/testdata/xmi/report_views.golden.sysml
@@ -36,11 +36,13 @@ package Viewpoints {
             doc /* Which hazards does the pump control? */
         }
         action def 'Collect Guards';
+        metadata MigrationMetadata::SynthesizedName about 'safety Inspector', maintainer;
     }
     viewpoint 'Operations Viewpoint' {
         doc /* Show how the pump is run. */
         subject;
         stakeholder operator : Stakeholders::Operator;
+        metadata MigrationMetadata::SynthesizedName about operator;
     }
     part def 'Plain Block';
 }
diff --git a/tests/migrate/testdata/xmi/station_points.golden.sysml b/tests/migrate/testdata/xmi/station_points.golden.sysml
index 2352bb778..1241d4b2d 100644
--- a/tests/migrate/testdata/xmi/station_points.golden.sysml
+++ b/tests/migrate/testdata/xmi/station_points.golden.sysml
@@ -128,6 +128,7 @@ part def Station {
                 }
             }
             transition first regions then done;
+            metadata MigrationMetadata::SynthesizedName about regions;
         }
         transition first Idle accept Go
             do action {
diff --git a/tests/migrate/testdata/xmi/stereotype_filters.golden.sysml b/tests/migrate/testdata/xmi/stereotype_filters.golden.sysml
index 321e8c8b0..fb9820799 100644
--- a/tests/migrate/testdata/xmi/stereotype_filters.golden.sysml
+++ b/tests/migrate/testdata/xmi/stereotype_filters.golden.sysml
@@ -57,6 +57,7 @@ package 'Depot Viewpoints' {
             }
             first 'Critical Items' then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'critical Items Method' : 'Critical Items Method';
     }
@@ -72,6 +73,7 @@ package 'Depot Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'exact Critical Layouts Method' : 'Exact Critical Layouts Method';
     }
@@ -87,6 +89,7 @@ package 'Depot Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'critical Figures Method' : 'Critical Figures Method';
     }
@@ -100,6 +103,7 @@ package 'Depot Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'uncritical Figures Method' : 'Uncritical Figures Method';
     }
@@ -115,6 +119,7 @@ package 'Depot Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'critical Layouts Method' : 'Critical Layouts Method';
     }
@@ -128,6 +133,7 @@ package 'Depot Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'satisfier Figures Method' : 'Satisfier Figures Method';
     }
@@ -143,6 +149,7 @@ package 'Depot Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'satisfier Layouts Method' : 'Satisfier Layouts Method';
     }
@@ -158,6 +165,7 @@ package 'Depot Viewpoints' {
             action Image;
             first Image then final;
             action final terminate;
+            metadata MigrationMetadata::SynthesizedName about final;
         }
         perform action 'owned Figures Method' : 'Owned Figures Method';
     }
diff --git a/tests/migrate/testdata/xmi/stub_actions.golden.sysml b/tests/migrate/testdata/xmi/stub_actions.golden.sysml
index 6d1d77c26..aa2360245 100644
--- a/tests/migrate/testdata/xmi/stub_actions.golden.sysml
+++ b/tests/migrate/testdata/xmi/stub_actions.golden.sysml
@@ -16,6 +16,7 @@ part def Rig {
         first 'set last' then final;
         action final terminate;
         bind 'set last'.value = value;
+        metadata MigrationMetadata::SynthesizedName about final;
     }
     action def Sampling {
         out sample : ScalarValues::Real[0..1];
@@ -49,6 +50,7 @@ part def Rig {
         flow gain.result to measure.gain;
         flow measure.reading to record.value;
         bind sample = measure.reading;
+        metadata MigrationMetadata::SynthesizedName about 'fork', fork2, 'join', join2, final;
     }
 }
 allocate Rig::Sampling::measure to Rig::probe;
diff --git a/tests/migrate/testdata/xmi/user_library.golden.sysml b/tests/migrate/testdata/xmi/user_library.golden.sysml
index add57d8ff..124bea100 100644
--- a/tests/migrate/testdata/xmi/user_library.golden.sysml
+++ b/tests/migrate/testdata/xmi/user_library.golden.sysml
@@ -22,5 +22,6 @@ part def Recorder {
         }
         first get then final;
         action final terminate;
+        metadata MigrationMetadata::SynthesizedName about final;
     }
 }
diff --git a/tests/migrate/testdata/xmi/weighted_decision.golden.sysml b/tests/migrate/testdata/xmi/weighted_decision.golden.sysml
index 8aef75f0e..a9de16338 100644
--- a/tests/migrate/testdata/xmi/weighted_decision.golden.sysml
+++ b/tests/migrate/testdata/xmi/weighted_decision.golden.sysml
@@ -21,6 +21,7 @@ part def Sorter {
         merge 'merge';
         first 'merge' then final;
         action final terminate;
+        metadata MigrationMetadata::SynthesizedName about 'decide', 'merge', final;
     }
     perform action route : Route;
 }