diff --git a/changes/unreleased/render-source-links.added.md b/changes/unreleased/render-source-links.added.md
new file mode 100644
index 0000000000..fc7b361d15
--- /dev/null
+++ b/changes/unreleased/render-source-links.added.md
@@ -0,0 +1 @@
+- **Link rendered diagram elements to their source.** PlantUML and DOT link nodes and edges, Mermaid links supported nodes and participants, and CLI, REPL, LSP and document renderings accept source-link templates.
diff --git a/cmd/sysml/main.go b/cmd/sysml/main.go
index 203b8cce23..5cfc081212 100644
--- a/cmd/sysml/main.go
+++ b/cmd/sysml/main.go
@@ -118,6 +118,7 @@ var (
 	renderAllDir     string
 	renderForm       string
 	renderPalette    string
+	renderLink       string
 	renderUnplaced   string
 	renderStyle      string
 	renderPorts      string
@@ -384,6 +385,10 @@ func runCLI() int {
 		fmt.Fprintln(os.Stderr, "sysml: -render-palette is the palette -render or -render-all fills DOT, Mermaid or PlantUML with; name the view to render with -render or a directory with -render-all")
 		return 2
 	}
+	if renderLink != "" && renderView == "" && renderAllDir == "" && renderDoc == "" && renderDocsDir == "" {
+		fmt.Fprintln(os.Stderr, "sysml: -render-link links rendered elements to their source; name what to render with -render, -render-all, -render-document or -render-documents")
+		return 2
+	}
 	if renderPorts != "" && renderView == "" && renderAllDir == "" {
 		fmt.Fprintln(os.Stderr, "sysml: -render-ports is how much of a part's ports -render or -render-all draws on an interconnection; name the view to render with -render or a directory with -render-all")
 		return 2
@@ -538,7 +543,7 @@ func runCLI() int {
 		case convertFormat != "" || migrateFormat != "" || renderView != "" || renderDoc != "" || renderAllDir != "" || renderDocsDir != "" || queryText != "" || len(evalExprs) > 0:
 			fmt.Fprintf(os.Stderr, "sysml: %s syncs a change set; it cannot be combined with -convert, -migrate, -render, -render-all, -render-document, -render-documents, -query or -eval\n", mode)
 			return 2
-		case outputPath != "" || fromFormat != "" || renderForm != "" || renderPalette != "" || renderUnplaced != "" || renderStyle != "" || renderPorts != "" || docForm != "" || diagramForm != "" || pdfEngine != "" || pdfTitlePage || pdfTOC || pdfNumbering || docNumberFigures:
+		case outputPath != "" || fromFormat != "" || renderForm != "" || renderPalette != "" || renderLink != "" || renderUnplaced != "" || renderStyle != "" || renderPorts != "" || docForm != "" || diagramForm != "" || pdfEngine != "" || pdfTitlePage || pdfTOC || pdfNumbering || docNumberFigures:
 			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 729b28ec8c..cd6c96f571 100644
--- a/cmd/sysml/render.go
+++ b/cmd/sysml/render.go
@@ -43,6 +43,12 @@ func runRender(files []string) error {
 	if err != nil {
 		return err
 	}
+	if options.Links.Template != "" {
+		options.Links.Sites, err = sess.ViewSites()
+		if err != nil {
+			return err
+		}
+	}
 	artifact, err := rendering.WriteWith(form, options)
 	if err != nil {
 		return err
@@ -75,6 +81,12 @@ func runRenderAll(files []string) error {
 	if len(views) == 0 {
 		return errors.New("the model declares no views; nothing was rendered")
 	}
+	if options.Links.Template != "" {
+		options.Links.Sites, err = sess.ViewSites()
+		if err != nil {
+			return err
+		}
+	}
 	if err := os.MkdirAll(renderAllDir, 0o750); err != nil {
 		return fmt.Errorf("create rendering directory %s: %w", renderAllDir, err)
 	}
@@ -144,6 +156,12 @@ func renderFilenames(views []model.ViewInfo, form view.Form) (map[string]string,
 // names, each of which must be one there is.
 func renderOptions(width int) (view.Options, error) {
 	options := view.Options{Width: width}
+	if renderLink != "" {
+		if err := view.ParseLinkTemplate(renderLink); err != nil {
+			return view.Options{}, fmt.Errorf("-render-link: %w", err)
+		}
+		options.Links.Template = renderLink
+	}
 	if renderPalette != "" {
 		palette, ok := view.ParsePalette(renderPalette)
 		if !ok {
diff --git a/cmd/sysml/render_document.go b/cmd/sysml/render_document.go
index 50005a7ff6..6ee221c690 100644
--- a/cmd/sysml/render_document.go
+++ b/cmd/sysml/render_document.go
@@ -139,6 +139,7 @@ func documentOptions(outputDir string) docrender.HTMLOptions {
 		DiagramForm:         view.Form(diagramForm),
 		Unplaced:            view.Unplaced(renderUnplaced),
 		Style:               view.DrawingStyle(renderStyle),
+		LinkTemplate:        renderLink,
 		Drawer:              replext.Drawer(),
 		WithoutGraphviz:     replext.Drawer() == nil,
 		OutputDir:           outputDir,
@@ -149,7 +150,7 @@ func documentOptions(outputDir string) docrender.HTMLOptions {
 // outputDir, "" for standard output.
 func markdownOptions(outputDir string) docrender.MarkdownOptions {
 	return docrender.MarkdownOptions{
-		DiagramForm: view.Form(diagramForm), Unplaced: view.Unplaced(renderUnplaced), Style: view.DrawingStyle(renderStyle),
+		DiagramForm: view.Form(diagramForm), Unplaced: view.Unplaced(renderUnplaced), Style: view.DrawingStyle(renderStyle), LinkTemplate: renderLink,
 		Drawer: replext.Drawer(), WithoutGraphviz: replext.Drawer() == nil,
 		OutputDir: outputDir, NumberFigures: docNumberFigures,
 	}
@@ -168,6 +169,11 @@ func artifactDir() string {
 // -render-unplaced value naming no placement and a -render-style value naming
 // no drawing style.
 func checkDiagramForm() error {
+	if renderLink != "" {
+		if err := view.ParseLinkTemplate(renderLink); err != nil {
+			return fmt.Errorf("-render-link: %w", err)
+		}
+	}
 	if _, err := unplacedOption(); err != nil {
 		return err
 	}
diff --git a/cmd/sysml/render_document_test.go b/cmd/sysml/render_document_test.go
index 003ca8cd60..3ec342781e 100644
--- a/cmd/sysml/render_document_test.go
+++ b/cmd/sysml/render_document_test.go
@@ -129,6 +129,21 @@ func TestRenderDocumentDiagramForm(t *testing.T) {
 		2, "SomeView")
 }
 
+func TestRenderDocumentDiagramSourceLinks(t *testing.T) {
+	binary := buildCLI(t)
+	fixture := filepath.Join("..", "..", "internal", "doc", "docrender", "testdata", "telescope_report.sysml")
+	template := "https://example.test/src/{file}#L{line}"
+	cmd := exec.Command(binary, fixture, "-render-document", "Observatory::MassReport", "-diagram-form", "plantuml", "-render-link", template)
+	out, err := cmd.Output()
+	if err != nil {
+		t.Fatalf("render linked document: %v", err)
+	}
+	want := "https://example.test/src/" + filepath.ToSlash(fixture) + "#L"
+	if !strings.Contains(string(out), want) || !strings.Contains(string(out), "[[") {
+		t.Errorf("document diagrams lack source links to %q:\n%s", want, out)
+	}
+}
+
 // TestRenderDocumentCommittedFixture renders the renderer's committed fixture
 // through the binary's full analysis, matching the committed golden Markdown.
 func TestRenderDocumentCommittedFixture(t *testing.T) {
diff --git a/cmd/sysml/render_pdf.go b/cmd/sysml/render_pdf.go
index a15f241e74..c86cf7ed4b 100644
--- a/cmd/sysml/render_pdf.go
+++ b/cmd/sysml/render_pdf.go
@@ -67,5 +67,6 @@ func pdfOptions() (docpdf.Options, error) {
 		DiagramForm:         page.DiagramForm,
 		Unplaced:            page.Unplaced,
 		Style:               page.Style,
+		LinkTemplate:        page.LinkTemplate,
 	}, nil
 }
diff --git a/cmd/sysml/render_test.go b/cmd/sysml/render_test.go
index b54950b0fb..0f14a8308b 100644
--- a/cmd/sysml/render_test.go
+++ b/cmd/sysml/render_test.go
@@ -307,6 +307,47 @@ func TestRenderPalette(t *testing.T) {
 	}
 }
 
+func TestRenderLinkFlag(t *testing.T) {
+	binary := buildCLI(t)
+	dir := t.TempDir()
+	path := writeModel(t, dir, "linked.sysml", `package Demo {
+    part def Vehicle;
+    view overview { expose Demo::Vehicle; }
+}
+`)
+	template := "https://example.test/src/{file}#L{line}:{col}"
+	got := runFiles(t, binary, []string{path}, "-render", "Demo::overview", "-render-form", "mermaid", "-render-link", template)
+	if got.status != exitHolds {
+		t.Fatalf("exit status = %d, want %d\n%s", got.status, exitHolds, got.output())
+	}
+	want := `click n0 href "https://example.test/src/` + filepath.ToSlash(path) + `#L2:`
+	if !strings.Contains(got.stdout, want) {
+		t.Errorf("rendered artifact lacks the source link %q:\n%s", want, got.stdout)
+	}
+
+	allDir := filepath.Join(t.TempDir(), "all")
+	all := runFiles(t, binary, []string{path}, "-render-all", allDir, "-render-form", "mermaid", "-render-link", template)
+	if all.status != exitHolds {
+		t.Fatalf("-render-all status = %d, want %d\n%s", all.status, exitHolds, all.output())
+	}
+	artifact, err := os.ReadFile(filepath.Join(allDir, "Demo.overview.mmd"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(artifact), want) {
+		t.Errorf("-render-all artifact lacks source links:\n%s", artifact)
+	}
+
+	invalid := runFiles(t, binary, []string{path}, "-render", "Demo::overview", "-render-link", "https://example.test/{unknown}")
+	if invalid.status != exitUnevaluable || !strings.Contains(invalid.stderr, "-render-link: unknown link template placeholder {unknown}") || invalid.stdout != "" {
+		t.Errorf("invalid link template = %d\n%s", invalid.status, invalid.output())
+	}
+	alone := runStreams(t, binary, renderModel, "-render-link", template)
+	if alone.status != 2 || !strings.Contains(alone.stderr, "-render-link links rendered elements to their source") {
+		t.Errorf("link template without a render target = %d\n%s", alone.status, alone.output())
+	}
+}
+
 // TestRenderSeveralFiles checks that a view declared in one file renders the
 // elements its sibling files declare, loaded as one model, on stdout and into
 // -o in the form -render-form names.
diff --git a/cmd/sysml/usage.go b/cmd/sysml/usage.go
index 9a57bcf382..89da0252f1 100644
--- a/cmd/sysml/usage.go
+++ b/cmd/sysml/usage.go
@@ -665,6 +665,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, plantuml, csv or tsv (csv and tsv for a table); default from the destination for -render, each kind's machine form for -render-all")
 	fs.StringVar(&renderPalette, "render-palette", "", "Palette the dot, mermaid 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(&renderLink, "render-link", "", "Link template for rendered elements: {file} is the path as loaded; use absolute paths for vscode:// or file:// links. Placeholders: {file}, {line}, {col}, {qname}, {id}")
 	fs.StringVar(&renderStyle, "render-style", "", "Drawing style of the dot or mermaid form: pilot (default), the Pilot visualizer's black and white, or cameo, the look of Cameo Systems Modeler; applies to -render, -render-all and document diagrams")
 	fs.StringVar(&renderPorts, "render-ports", "", "How much of a part's ports -render or -render-all draws on an interconnection: minimal (default), the ports its connectors end at, each a small square on the part's border named beside it, or full, every port, labelled name : Type")
 	fs.StringVar(&renderUnplaced, "render-unplaced", "", "Where a graph form of a view some Layout positions puts the nodes none does: omit (default) leaves them undrawn in every form, strip draws them, in rows below the dot drawing; applies to -render, -render-all and document diagrams")
@@ -790,6 +791,7 @@ func optionGroups() []usage.OptionGroup {
 			usage.Opt("render-all", "<dir>"),
 			usage.Opt("render-form", formArg),
 			usage.Opt("render-palette", "<palette>"),
+			usage.Opt("render-link", "<template>"),
 			usage.Opt("render-unplaced", "<placement>"),
 			usage.Opt("render-style", "<style>"),
 			usage.Opt("render-ports", "<display>"),
diff --git a/docs/project/html-document-backend.md b/docs/project/html-document-backend.md
index 3081e0eebf..6f8d669b86 100644
--- a/docs/project/html-document-backend.md
+++ b/docs/project/html-document-backend.md
@@ -239,6 +239,15 @@ is replaced by `<img>` with the caption as its `alt` text; that is the path the
 use, since no print engine runs Mermaid. Table-kind views keep rendering as a table, as they do
 in Markdown.
 
+An optional source-link template is applied to the nodes and edges that can be located in the
+diagram's source model. HTML documents do not create element-anchored sections, so links back into
+the document are not available as a substitute for source links. This backend leaves Mermaid's
+`securityLevel` unset. Mermaid CLI 11.16.0 defaults to `strict`, which strips links with
+non-HTTP(S) schemes, including `vscode://` and `file:///`. It rewrites sequence hrefs under both
+`strict` and `loose`: `https://example.com/c%5D%22%23#L3` becomes `https://example.com/c]%22#`,
+losing its fragment. `{"securityLevel":"loose"}` preserves non-HTTP(S) schemes, but not the URL
+rewriting or fragment loss.
+
 Supplying the images stays out of `docrender`: rendering them means running `mmdc` as a
 subprocess, which is `docpdf`'s job and must not become a dependency of a pure renderer. So
 `docrender` exposes the diagram sources in document order and accepts the resulting image
diff --git a/docs/project/spec-compliance.md b/docs/project/spec-compliance.md
index 9d5a16843b..2acbc3e6d3 100644
--- a/docs/project/spec-compliance.md
+++ b/docs/project/spec-compliance.md
@@ -1892,6 +1892,7 @@ reference to an inherited element is not a name conflict.
 | A view owns at most one view rendering: a second `render` member is an error, in a view definition and in a view usage alike (SysML v2 §8.3.26; `validateViewDefinitionOnlyOneViewRendering` / `validateViewUsageOnlyOneRendering`) | `passes/w8d_view_rendering.go` `W8DViewRenderingPass` | `passes/w8d_view_rendering_test.go`; see the SysML-half validation section for the reference verdicts | ✅ Faithful |
 | `expose` in a view body is an Import | see the Name Resolution section's `expose` rows | `parser/expose_test.go`, `resolve/expose_test.go`, `parse/view_expose.golden` | ✅ Faithful (`validateExposeOwningNamespace` reports an `expose` outside a view usage — see the Name Resolution section's `expose` rows) |
 | A view usage's `expose` admits only what satisfies the `filter` conditions of the usage *and* of its view definition and that definition's supertypes (SysML v2 §7.24 Views: a view usage inherits its definition's element filters) | `resolve/filter.go` `Resolver.importAdmits`, `inheritedViewConditions` (memoised per view scope, cycle-guarded), `viewOwnConditions` | `semantics/expose_test.go` `TestExposedElementsSatisfyInheritedViewConditions`, `cmd/sysml/render_test.go` `TestRenderAllOOSEMViews` (library-backed view definitions) | ✅ Faithful |
+| A rendering may link located source nodes and edges with a template without changing the artifact when disabled or when no source site is available; workspace-backed links freeze node, nested-node, port and edge sites under the lock, anonymous symbols have no qualified name, and site memoization is concurrency-safe | `ir/view/links.go` `Renderer.Sites` (mutex-protected cache and named-symbol qualification); `workspace/model/render.go` `RenderViewLinked` (frozen site map); `ir/view/dot.go`, `plantuml.go`, `mermaid.go` write only the links each notation supports | `view/links_test.go` `TestLinkedDiagramGoldens`, `TestWriteWithNoSitesIsByteIdentical`, `TestLinkWritersDoNotLinkZeroOrigins`, `TestPlantUMLLinksPrecedeColorsAndExcludePorts`, `TestPlantUMLPseudostateLinksAreOmittedWhenSVGDropsThem`, `TestLinkedFormsRenderAsSVG`, `TestDOTCompositeLinkRendersAsVisibleClusterAnchor`, `TestPlantUMLLinkedArrowFormsRenderAsSVG`, `TestMermaidSequenceLinkFragmentsAreDroppedInSVG`, `TestRendererSitesMemoizesConcurrentLookups`, `TestRendererSitesLeaveAnonymousQualifiedNameEmpty`; `workspace/model/render_test.go` `TestRenderViewLinkedFreezesNodePortAndEdgeSites`; `repl/view_render_test.go` `TestRenderLinksUseLoadedSourcePositions`; `lsp/render_test.go` `TestRenderWritesSourceLinks`; `docrender/markdown_test.go` `TestMarkdownDiagramSourceLinks`, `docrender/html_test.go` `TestHTMLDiagramSourceLinks` | ✅ Implemented (DOT composite links are cluster anchors; PlantUML SVG omits links on the pseudostate stereotypes that lose them, with unlinked children in a linked composite taking the composite's link; Mermaid CLI 11.16.0 drops sequence URL fragments and rewrites percent-encoded hrefs, while strict mode strips non-HTTP(S) links; see [view rendering forms](view-rendering-forms.md#source-links)) |
 
 ### Structural, Interface and Analysis Notation (SysML v2 §7.12 Ports, §8.2.2.14 Interfaces, §8.2.2.19 Analysis Cases, §8.3.9.11 Occurrences)
 
@@ -2098,7 +2099,7 @@ semantics layer over the conjugation parity of the typing/specialization chain.
 | 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` 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) |
+| 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. Source links are written only for elements with on-disk source sites when the caller supplies a template; 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, Mermaid and PlantUML forms fill nodes with by keyword family, using the same hex per node in the DOT/Mermaid forms and the same fill in PlantUML: `okabe-ito`, `tol-bright`, `tol-muted`, `tol-light`, `brewer-set2`, `brewer-dark2`, `viridis` and `cividis`. A definition takes its family colour, a usage a 60% tint, with fills adjusted for black-text contrast; pseudostates, control nodes and cluster borders stay black and white. `classDef`/`class` writes Mermaid fills, and palettes override Cameo fills. The palette travels through `Diagram::palette`, CLI, REPL, `opensysml/render`, document plan/IR and HTML `data-palette`; Mermaid sequence diagrams accept a palette but report that they cannot fill individual participants. Text and Markdown ignore palettes; unknown names and palettes on table diagrams are typed errors | `view/palette.go` `Palette`, `Palettes`, `ParsePalette`, `PaletteNames`, `Palette.check`, `Palette.Color`, `Palette.Sequential`, `paletteFill`, `legibleFill`, `Kind.SupportsPalette`, `Form.TakesPalette`, `familyFills`; `view/mermaid.go` `MermaidWith`; `libs/stdlib/OpenSysML Libraries/DocumentQueries.sysml` `Diagram::palette`; `docplan/compiler.go` `compileDiagram`; `docir/ir.go` `Content.Palette`, `Content.Options`; `docrender/markdown.go`, `docrender/html.go`; `cmd/sysml/render.go`; `repl/view.go`, `repl/complete.go`; `lsp/render.go` | `view/palette_test.go`, `view/dot_style_test.go`; `view/plantuml_test.go:TestPlantUMLPaletteParityWithDOT`; `view/mermaid_test.go:TestMermaidPaletteParityWithDOT`, `TestGoldenMermaidPalette`; `docplan/diagram_test.go`; `docrender/html_diagram_test.go`; CLI, REPL and LSP render tests | ✅ Faithful to the shared palette family fills; Mermaid sequences explicitly report their participant-fill limitation |
 | A diagram node's label follows the graphical notation's header (SysML v2 §8.2.2.2): the element's name first, with ` : Type` after it for a typed usage, the kind on the next line in guillemets, and notes after that; an anonymous element leads with its kind and has no keyword line. The declared type is carried separately as `Node.Type`, the detail carries notes alone, and no writer parses type out of detail. Mermaid flowchart nodes and subgraph titles use Markdown only when every label line is safe: head lines are bold, the keyword is italic, details are plain, separated by real newlines; punctuation, list-like prefixes, non-multiplicity `*` and non-intraword `_` fall back to the escaped plain label. State, sequence and edge labels remain unchanged; flowchart titles add `subGraphTitleMargin` frontmatter when necessary. DOT uses HTML-like labels, PlantUML uses creole, and text keeps keyword-leading declaration order | `view/label.go` `labelHead`, `labelLines`; `view/mermaid.go` `mermaidLabel`, `writeFlowchartFrontmatter`; `view/dot.go` `dotLabel`, `dotEscape`, `dotLabelExtent`; `view/plantuml.go` `plantumlLabel`, `plantumlText`; `view/text.go` `writeNodeText`; `view/view.go` `Node.Type`; `lsp/render.go` `renderNode.Type`; `editors/vscode/src/protocol.ts` `RenderNode.type` | `view/label_test.go`; `view/mermaid_test.go:TestMermaidMarkdownLabelsFallBackWhenUnsafe`; `view/render_test.go:TestMermaidLabelsAreEscaped`; `view/testdata/*.{mermaid,dot,plantuml,text}.golden`; `docrender/testdata/telescope_report.*.golden.*` | ✅ Faithful to the notation; Mermaid Markdown labels fall back when unsafe |
diff --git a/docs/project/view-rendering-forms.md b/docs/project/view-rendering-forms.md
index 839a0e351f..ef4f88b9f1 100644
--- a/docs/project/view-rendering-forms.md
+++ b/docs/project/view-rendering-forms.md
@@ -804,8 +804,34 @@ pseudostate shape only when nothing else is attached.
   family (fill only; PlantUML takes no border colour on a participant), so the palette is
   represented, not noticed.
 
-Hyperlinks are not written: no writer derives a stable URL from `Origin` today, and the PlantUML
-form adds none on its own; `[[url]]` links stay open with the DOT `URL=` attribute.
+### Source links
+
+The view renderer can resolve each located node and edge to a source `Site` and expand a
+`-render-link` template containing `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`. The
+`{line}` value is one-based and `{col}` is a byte column. Substituted values preserve ASCII
+unreserved characters, `/` and `:` and percent-encode every other UTF-8 byte; template literals
+keep URL delimiters such as `%`, `#`, `?` and `&`, while unsafe bytes are escaped. `{file}` is the
+path as loaded, so absolute input paths are recommended when links must be opened from another
+working directory. A declaration without a locatable on-disk source site — including synthetic
+origins and bundled library declarations — is not linked.
+
+| Form | Linked elements |
+| --- | --- |
+| DOT | Nodes and edges receive quoted `URL` and `tooltip` attributes; a composite node's URL and tooltip are cluster attributes, not attributes of its invisible anchor. The tooltip is the qualified name when available, otherwise `file:line:col`. |
+| PlantUML | Linkable nodes carry `[[url]]` after stereotypes and before palette colors, and edges carry links. PlantUML SVG drops links on `<<start>>`, `<<fork>>`, `<<join>>`, `<<end>>`, `<<choice>>`, `<<history>>` and `<<history*>>` pseudostates; an unlinked pseudostate inside a linked composite state takes the composite's link. Ports and initial/start pseudostate arrows are not linked. |
+| Mermaid flowchart | Linkable nodes receive `click` statements after the edges and classes. Edges and subgraphs are not linked. |
+| Mermaid state diagram | Simple states are linked; composite states are not. |
+| Mermaid sequence diagram | Participants receive `link` statements; messages are not linked. Mermaid CLI 11.16.0 drops participant URL fragments in SVG. |
+
+The writers emit no link syntax when links are disabled or no site is available.
+
+The HTML backend leaves Mermaid's `securityLevel` unset. Mermaid CLI 11.16.0 defaults to
+`strict`, which strips links with non-HTTP(S) schemes, including `vscode://` and `file:///`.
+It also rewrites sequence hrefs under both `strict` and `loose`: a link to
+`https://example.com/c%5D%22%23#L3` becomes `https://example.com/c]%22#`, losing its fragment.
+Setting `{"securityLevel":"loose"}` preserves non-HTTP(S) schemes, but not the URL rewriting or
+fragment loss. Composite states and subgraphs receive no `<a>` from the writer; a consumer
+rendering Mermaid source controls its own security level.
 
 ### The inline style
 
@@ -987,8 +1013,6 @@ and did not change. A view-render RPC added later would take the form as a strin
   `portin`/`portout`.
 - PlantUML prints no stereotype: `hide stereotype` is written so the label's keyword line is the
   one guillemet line; the stereotypes drive only the style and the pseudostate shapes.
-- No `[[url]]` hyperlinks are written by the PlantUML form, no writer having a stable URL for a
-  node's `Origin`.
 - Producing PlantUML runs no jar. The goldens are checked by the in-test syntax walk; a jar on
   the machine is used by hand, or by the optional `-checkonly` check that `OPENSYSML_PLANTUML_JAR`
   turns on.
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index ed882ba520..8c48e7c508 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -245,6 +245,7 @@ the same member-path parser as `Project` and `OrderBy`.
 | `--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`, `plantuml`, `csv` or `tsv` (default: destination-dependent for `--render`, each kind's machine-readable form for `--render-all`) |
 | `--render-palette <name>` | | Palette the `dot`, `mermaid` 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 sequence diagrams cannot fill individual participants; text and Markdown ignore palettes. An unknown name is refused with the names there are (see [Rendering a view](#rendering-a-view)) |
+| `--render-link <template>` | | Link nodes and edges back to their source in rendered diagrams. Templates accept `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`; `{file}` is the path as loaded, so pass absolute paths for `vscode://` or `file://` links. Applies to `--render`, `--render-all` and document diagrams; without one of those render targets it is refused |
 | `--render-style <style>` | | Drawing style the `dot` or `mermaid` form of `--render`, `--render-all`, `--render-document` and `--render-documents` draws in: `pilot` (the default), the Pilot visualizer's Standard B&W, or `cameo`, the look of Cameo Systems Modeler — a diagram frame with a header tab, 11 pt Arial, gradient fills in Cameo's colours, a state's `do / Activity` compartment and the UML pseudo-state symbols. Mermaid draws supported Cameo details but flattens gradients and omits the frame and header tab; unsupported details are noted. PlantUML notes the style as not represented; text and Markdown ignore it. An unknown name is refused with the two there are; without something to render it is refused likewise (see [Rendering a view](#rendering-a-view)) |
 | `--render-ports <display>` | | How much of a part's ports the interconnection of `--render` or `--render-all` draws: `minimal` (the default), the ports its connectors end at, each a small square on the part's border named beside it, or `full`, every port a part has, labelled `name : Type`. An unknown name is refused with the two there are |
 | `--render-unplaced <placement>` | | Where a graph form of a view some `DiagramLayout::Layout` positions puts the nodes none does: `omit` (the default) leaves them, and the edges at them, undrawn in every form, so the `mermaid`, `dot` and `plantuml` forms draw one node set; `strip` draws them too, in rows below the `dot` drawing, clear of the canvas and every positioned box, and among the placed nodes in the forms that lay nodes out themselves. Applies to `--render`, `--render-all` and the 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)) |
@@ -507,6 +508,10 @@ sysml model.sysml -render Views::vehicleView -render-form dot -render-unplaced s
 sysml model.sysml -render Views::vehicleView -render-form plantuml -o view.puml
 sysml model.sysml -render Views::handshake -render-form plantuml -render-palette tol-bright -o handshake.puml
 
+# Link diagram elements to the declarations' source locations
+sysml /absolute/path/model.sysml -render Views::vehicleView -render-form dot \
+  -render-link 'vscode://file/{file}:{line}:{col}' -o view.dot
+
 # A table as comma- or tab-separated values, for a spreadsheet or a script
 sysml model.sysml -render Views::partsTable -render-form csv -o parts.csv
 sysml model.sysml -render Views::partsTable -render-form tsv | cut -f1,3
@@ -704,6 +709,24 @@ cannot fill individual participants. Text and Markdown ignore palettes. A name t
 status 2 and the names there are; `-render-palette` without `-render` or `-render-all` is refused
 likewise.
 
+`-render-link <template>` gives linkable diagram nodes and edges URLs to their source. A template
+may contain `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`. Substituted values are UTF-8
+percent-encoded; URL delimiters written literally in the template remain literal. `{file}` is the
+path as loaded, not a path resolved against the rendering's output directory: use absolute input
+paths when a link must work outside the process's working directory. Synthetic origins, missed
+source locations and bundled library declarations are left unlinked. DOT writes `URL` and
+`tooltip` attributes; PlantUML writes `[[url]]` on nodes and edges (not ports or initial
+pseudostate arrows); Mermaid writes `click` statements for non-composite flowchart and simple state
+nodes and `link` statements for sequence participants, but not edges, subgraphs or composite
+states. The pinned Mermaid CLI 11.16.0 defaults to `securityLevel: strict`, which strips links
+with non-HTTP(S) schemes, including `vscode://` and `file:///`. It rewrites sequence hrefs under
+both `strict` and `loose`: `https://example.com/c%5D%22%23#L3` becomes
+`https://example.com/c]%22#`, losing its fragment. `{"securityLevel":"loose"}` preserves those
+schemes, but not the URL rewriting or fragment loss. In document
+output, source links are supported for diagram elements; HTML does not create element-anchored
+sections. The option requires `-render`, `-render-all`,
+`-render-document` or `-render-documents`.
+
 `-render-style <style>` names the look the DOT and Mermaid forms draw in. `pilot`, the default, is the Pilot
 visualizer's Standard B&W above; `cameo` is the look of Cameo Systems Modeler, for a diagram
 migrated from a `.mdzip` to keep the look its authors saw: a diagram frame with the
diff --git a/docs/reference/lsp.md b/docs/reference/lsp.md
index f418a0a2c0..307193b9f1 100644
--- a/docs/reference/lsp.md
+++ b/docs/reference/lsp.md
@@ -127,6 +127,11 @@ Renders one view of a document.
 | `palette` | Optional. A palette the `dot`, `mermaid` and `plantuml` forms fill nodes with by keyword family: `okabe-ito`, `tol-bright`, `tol-muted`, `tol-light`, `brewer-set2`, `brewer-dark2`, `viridis` or `cividis` ([the palettes](../project/view-rendering-forms.md#palettes)). Omitted or empty draws black and white. Mermaid sequence diagrams note that they cannot fill individual participants; `text` and `markdown` ignore palettes. A server advertising `openSysmlRenderPalette` gives each node the palette colours as `fill` and `border`, so a client drawing the nodes itself can use the same colours. |
 | `style` | Optional. The drawing style the `dot` or `mermaid` form draws in: `pilot` (the default, the Pilot visualizer's B&W) or `cameo`, the look of Cameo Systems Modeler — 11 pt Arial, gradient fills in Cameo's colours, compartments and UML pseudo-state symbols ([the measurements](../project/view-rendering-forms.md#the-cameo-style)). Mermaid draws supported Cameo details but flattens gradients and omits the frame and header tab; unsupported details are noted. PlantUML notes a style other than `pilot` as not represented; `text` and `markdown` ignore it. The result's `style` names the style drawn, the default when omitted. |
 | `ports` | Optional. How much of a part's ports an interconnection draws: `minimal` (the default), the ports a connector of the view ends at, each a small square on the part's border named beside it, or `full`, every port a part has, labelled `name : Type`. Other kinds ignore it. |
+| `linkTemplate` | Optional. Template for source links on diagram elements, with `{file}`, `{line}`, `{col}`, `{qname}` and `{id}` placeholders. `{file}` is the path as loaded. Only on-disk workspace documents are linked; bundled libraries and non-file documents have no source link. |
+
+The VS Code export sends `<uriScheme>://file/{file}:{line}:{col}`. Those links survive in DOT
+and PlantUML SVG, but Mermaid CLI 11.16.0's default strict-mode renderer strips them because
+their scheme is not HTTP(S).
 
 Omitting `view` renders the view the document declares. If the document declares
 several, the request is ambiguous and fails, naming them
@@ -340,6 +345,10 @@ request fails with the typed error's message (for example `Observatory::Subsyste
 is not a document: one is a part def specializing DocumentQueries::Document`)
 rather than crashing or answering with partial output.
 
+An optional `linkTemplate` request field applies `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`
+to linkable diagram elements. Only on-disk workspace documents are linked; bundled libraries and
+non-file documents have no source link.
+
 ## `opensysml/stdlibContent` (request)
 
 The server bundles the standard library, so a definition, reference, hover or
diff --git a/docs/reference/repl-commands.md b/docs/reference/repl-commands.md
index 9cd3fd2fd8..b6d7adc039 100644
--- a/docs/reference/repl-commands.md
+++ b/docs/reference/repl-commands.md
@@ -69,7 +69,7 @@ into the parts it holds (`car.fl.hub`, `#3.fl`, `car.wheels[2]`).
 | `%search <substring>` | List the declared and library symbols whose qualified name contains the substring, with the kind of each |
 | `%builtins` | List the library functions the runtime implements directly (`sqrt`, `abs`, `max`, `floor`, `x->isEmpty()`, `x->sum()` …), each with the package an `import` must name for its bare name to resolve; the qualified name (`RealFunctions::sqrt(2.0)`) resolves anywhere |
 | `%view <name>` | Show what a view exposes: its own `expose` relationships plus the protected ones of the views it specializes, the views nested in it (each with its own exposed set), and its conformance to every viewpoint it satisfies. Conformance is a verdict of `conforms`, `violated` or `unevaluable` per viewpoint and per framed concern, with the reason, the exposed element a concern's condition failed for, and `(from <view>)` where the `satisfy` is inherited. Asking about an element that is not a view says so |
-| `%render <name> [form [palette] [style] [ports]]` | Render a view's exposed set in the kind its `render` member states: a containment tree with nested views as subtrees, an interconnection diagram of the exposed parts and the connections between them, a state machine's states and transitions, an action's nodes and successions, or a table of the exposed elements and what they declare. A view with no `render` member renders as a tree. Output is indented text by default, or the machine-readable form of the kind: a [Mermaid](#rendering-a-view) diagram with `mermaid`, a Markdown table with `markdown`, or a table as comma- or tab-separated values with `csv` or `tsv`, any notice listed after the records under `not represented:`; `dot` writes a graph-shaped kind as Graphviz DOT instead of Mermaid, in the Pilot visualizer's Standard B&W style, `plantuml` writes it — a sequence included — as PlantUML in the same style, and `dot <palette>` or `plantuml <palette>` fills the nodes by keyword family from `okabe-ito`, `tol-bright`, `tol-muted`, `tol-light`, `brewer-set2`, `brewer-dark2`, `viridis` or `cividis`; an unknown palette is refused with the names there are; `dot [palette] pilot` or `dot [palette] cameo` names the drawing style, the Pilot look (the default) or Cameo Systems Modeler's, and an unknown style is refused with the two there are. Asking for a form the kind cannot be written in tells you which form it uses. Read-only: it creates no object and leaves a `%action`/`%state` debugging session running. A view that exposes nothing renders empty and says so; a rendering kind this build does not produce is reported by kind and view rather than rendered as something else; an element the rendering cannot represent is reported, not dropped |
+| `%render <name> [form [palette] [style] [ports] [link=<template>]]` | Render a view's exposed set in the kind its `render` member states: a containment tree with nested views as subtrees, an interconnection diagram of the exposed parts and the connections between them, a state machine's states and transitions, an action's nodes and successions, or a table of the exposed elements and what they declare. A view with no `render` member renders as a tree. Output is indented text by default, or the machine-readable form of the kind: a [Mermaid](#rendering-a-view) diagram with `mermaid`, a Markdown table with `markdown`, or a table as comma- or tab-separated values with `csv` or `tsv`, any notice listed after the records under `not represented:`; `dot` writes a graph-shaped kind as Graphviz DOT instead of Mermaid, in the Pilot visualizer's Standard B&W style, `plantuml` writes it — a sequence included — as PlantUML in the same style, and `dot <palette>` or `plantuml <palette>` fills the nodes by keyword family from `okabe-ito`, `tol-bright`, `tol-muted`, `tol-light`, `brewer-set2`, `brewer-dark2`, `viridis` or `cividis`; an unknown palette is refused with the names there are; `dot [palette] pilot` or `dot [palette] cameo` names the drawing style, the Pilot look (the default) or Cameo Systems Modeler's, and an unknown style is refused with the two there are. `link=<template>` links diagram elements to their source and accepts `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`; `{file}` is the path as loaded. Asking for a form the kind cannot be written in tells you which form it uses. Read-only: it creates no object and leaves a `%action`/`%state` debugging session running. A view that exposes nothing renders empty and says so; a rendering kind this build does not produce is reported by kind and view rather than rendered as something else; an element the rendering cannot represent is reported, not dropped |
 | **Instantiation & Inspection** | |
 | `%instantiate <name>` | Create an object of a part definition and start the behaviors its type exhibits or performs. Each object runs its own machine, initialized after its feature values are built and run until it is quiescent. A second `%instantiate` of the same name creates a new object, and the name then refers to that one. A later submission keeps the object's identity but restarts its behaviors from their initial states, and says so |
 | `%features <object> [all\|depth <n>] [json]` | Show what an object holds for each feature of its type. The object is named, addressed by id, or reached by a path: `%features car`, `%features #3`, `%features car.fl.hub`, `%features car.wheels[2]`. A feature with no value reads `<unset>`. States and actions hold no value, so they are listed after the values under a `Behaviors:` heading with what the object is doing with each: the current active state of a machine it exhibits (the state `%current` reports), the execution state of an action it performs, `not running` for a state or action it neither exhibits nor performs, or, for a named transition, the step it declares (`toggle: transition, modes.closed → modes.opened`). A behavior a redefinition renamed (`exhibit state fancyModes :>> modes`) is one execution under two names, and both rows report it. The values a running behavior owns — the attributes of the machine's own occurrence, an action's parameters and outputs — are listed under its row (`modes: exhibited state machine, current state running` followed by `count = 1`), apart from the performer's own values, and are bounded like any nested object. Reading a feature value builds the objects it holds, so the listing is bounded by default — 200 lines, nesting 8 deep — and a listing cut short says which form shows the rest. `all` lifts both bounds and reads the whole tree out; `depth <n>` bounds nesting at `n` levels and lifts the size bound, naming what it did not expand (`machine : Machine (not expanded: depth 1)`). `json` writes the object and everything reachable from it as one document in the shape the API's `Instantiate` returns (`instance`, `instances`, `diagnostics`), bounded by default at 1000 objects, with a graph cut short reported as a `warning` diagnostic. `all`/`depth` and `json` combine (`%features ctx all json`); `all` and `depth` together, a missing or negative depth, and an unknown word are errors naming the usage |
@@ -527,6 +527,11 @@ omitted frame. A member's own `DiagramLayout::Style` colours it over either look
 A `sequence` or `table` view has no DOT form, and asking for one tells you which form the kind
 uses.
 
+The optional `link=<template>` argument can follow the form and any palette, style or port display.
+Its placeholders are `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`. `{file}` is the path as
+loaded; absolute paths are recommended for `vscode://` or `file://` links. Only located source
+declarations are linked. For example, `%render Views::vehicleView dot link=vscode://file/{file}:{line}:{col}`.
+
 PlantUML is the other alternative, for a PlantUML toolchain — the OMG Pilot's own visualizer
 draws with PlantUML — and the one that also writes a `sequence` view. It carries the same B&W
 style inline as a `<style>` block, so the file stands alone; writing it needs no Java and no
diff --git a/editors/vscode/src/diagram.ts b/editors/vscode/src/diagram.ts
index ebd9d0944b..01c0d70f81 100644
--- a/editors/vscode/src/diagram.ts
+++ b/editors/vscode/src/diagram.ts
@@ -420,7 +420,10 @@ export class DiagramPanels implements vscode.Disposable {
     };
     const drawing = drawingStyleOf(diagramStyle(resolved.uri));
     const style = drawing !== undefined && supportsStyle(client, drawing) ? drawing : undefined;
-    const outcome = await exportRendering(host, { uri, documentName, view, forms: serverForms(experimental(client)), style });
+    const outcome = await exportRendering(host, {
+      uri, documentName, view, forms: serverForms(experimental(client)), style,
+      linkTemplate: `${vscode.env.uriScheme}://file/{file}:{line}:{col}`,
+    });
     switch (outcome.kind) {
       case "saved":
         this.output.appendLine(`Exported ${outcome.form} of ${documentName} to ${vscode.Uri.parse(outcome.location).fsPath}`);
diff --git a/editors/vscode/src/export.test.ts b/editors/vscode/src/export.test.ts
index 810dd0a354..1a6027addd 100644
--- a/editors/vscode/src/export.test.ts
+++ b/editors/vscode/src/export.test.ts
@@ -71,13 +71,18 @@ test("serverStyles takes the drawing styles the server advertises, none from a s
   assert.deepEqual(serverStyles({ [RENDER_STYLES_CAPABILITY]: ["cameo", 3] }), []);
 });
 
-test("an export asks the server for the drawing style the panel draws in, and for none under the other looks", async () => {
+test("an export asks the server for the drawing style and source links, and omits an absent style", async () => {
   const styled = new FakeHost("dot", echoForm);
-  await exportRendering(styled, { uri: "file:///ws/kit.sysml", documentName: "kit.sysml", view: "", forms: ["dot"], style: "cameo" });
+  await exportRendering(styled, {
+    uri: "file:///ws/kit.sysml", documentName: "kit.sysml", view: "", forms: ["dot"], style: "cameo",
+    linkTemplate: "vscode://file/{file}:{line}:{col}",
+  });
   assert.equal(styled.requests[0].style, "cameo");
+  assert.equal(styled.requests[0].linkTemplate, "vscode://file/{file}:{line}:{col}");
   const plain = new FakeHost("dot", echoForm);
   await exportRendering(plain, { uri: "file:///ws/kit.sysml", documentName: "kit.sysml", view: "", forms: ["dot"] });
   assert.equal(plain.requests[0].style, undefined);
+  assert.equal(plain.requests[0].linkTemplate, undefined);
 });
 
 test("serverForms takes the forms the server advertises, else the documented five", () => {
diff --git a/editors/vscode/src/export.ts b/editors/vscode/src/export.ts
index ca38ca06ea..6974bdd120 100644
--- a/editors/vscode/src/export.ts
+++ b/editors/vscode/src/export.ts
@@ -110,6 +110,8 @@ export interface ExportRequest {
   forms: readonly string[];
   /** The drawing style asked of the DOT form, when the panel's style names one the server draws. */
   style?: string;
+  /** Links diagram elements to the declaration in the source document. */
+  linkTemplate?: string;
 }
 
 /**
@@ -128,6 +130,9 @@ export async function exportRendering(host: ExportHost, request: ExportRequest):
     if (request.style !== undefined) {
       params.style = request.style;
     }
+    if (request.linkTemplate !== undefined) {
+      params.linkTemplate = request.linkTemplate;
+    }
     result = await host.render(params);
   } catch (err) {
     return { kind: "failed", step: "render", message: errorMessage(err) };
diff --git a/editors/vscode/src/protocol.ts b/editors/vscode/src/protocol.ts
index 619704d53b..1c6a21d46d 100644
--- a/editors/vscode/src/protocol.ts
+++ b/editors/vscode/src/protocol.ts
@@ -167,6 +167,8 @@ export interface RenderParams {
   palette?: string;
   /** The drawing style the DOT form is drawn in, one the server lists under `openSysmlRenderStyles`; absent is its default, `pilot`. */
   style?: string;
+  /** The link template each diagram element is written with. */
+  linkTemplate?: string;
 }
 
 export interface RenderResult {
diff --git a/internal/doc/docir/diagram_test.go b/internal/doc/docir/diagram_test.go
index 667f105455..2b3863dc99 100644
--- a/internal/doc/docir/diagram_test.go
+++ b/internal/doc/docir/diagram_test.go
@@ -1,6 +1,7 @@
 package docir
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
@@ -63,7 +64,7 @@ func TestEvaluateDiagramFromDeclaredView(t *testing.T) {
 	if diagram.Direction() != "" || diagram.Palette() != "" {
 		t.Fatalf("direction = %q, palette = %q", diagram.Direction(), diagram.Palette())
 	}
-	if options := diagram.Options(); options != (view.Options{}) {
+	if options := diagram.Options(); !reflect.DeepEqual(options, view.Options{}) {
 		t.Fatalf("options = %+v", options)
 	}
 	rendering := diagram.Rendering()
@@ -139,10 +140,10 @@ func TestEvaluateDiagramCarriesThePalette(t *testing.T) {
 		t.Fatalf("palette = %q", diagram.Palette())
 	}
 	want := view.Options{Direction: view.DirectionLeftRight, Palette: view.PaletteTolMuted}
-	if diagram.Options() != want {
+	if !reflect.DeepEqual(diagram.Options(), want) {
 		t.Fatalf("options = %+v, want %+v", diagram.Options(), want)
 	}
-	if clone := cloneContent([]Content{diagram})[0]; clone.Options() != want {
+	if clone := cloneContent([]Content{diagram})[0]; !reflect.DeepEqual(clone.Options(), want) {
 		t.Fatalf("cloned options = %+v", clone.Options())
 	}
 }
@@ -160,10 +161,10 @@ func TestEvaluateDiagramCarriesThePortDisplay(t *testing.T) {
 		t.Fatalf("ports = %q", diagram.Ports())
 	}
 	want := view.Options{Ports: view.PortsFull}
-	if diagram.Options() != want {
+	if !reflect.DeepEqual(diagram.Options(), want) {
 		t.Fatalf("options = %+v, want %+v", diagram.Options(), want)
 	}
-	if clone := cloneContent([]Content{diagram})[0]; clone.Options() != want {
+	if clone := cloneContent([]Content{diagram})[0]; !reflect.DeepEqual(clone.Options(), want) {
 		t.Fatalf("clone options = %+v, want %+v", clone.Options(), want)
 	}
 }
diff --git a/internal/doc/docir/evaluate.go b/internal/doc/docir/evaluate.go
index af99f3d45e..b02536e297 100644
--- a/internal/doc/docir/evaluate.go
+++ b/internal/doc/docir/evaluate.go
@@ -768,6 +768,7 @@ func (e *evaluator) evaluateDiagram(node docplan.Content) (Content, error) {
 		}
 	}
 	renderer := view.NewRenderer(e.context.Model, e.context.Resolver, e.text)
+	sites := renderer.Sites(view.FileLocator(e.context.Model, e.context.LineIndex))
 	var rendering *view.Rendering
 	var err error
 	if declared, ok := reference.View(); ok {
@@ -796,6 +797,7 @@ func (e *evaluator) evaluateDiagram(node docplan.Content) (Content, error) {
 		name:      node.Name(),
 		caption:   node.Caption(),
 		rendering: rendering,
+		sites:     sites,
 		direction: reference.Direction(),
 		palette:   reference.Palette(),
 		ports:     reference.Ports(),
diff --git a/internal/doc/docir/ir.go b/internal/doc/docir/ir.go
index 0d56cfcb65..6dccc8b15f 100644
--- a/internal/doc/docir/ir.go
+++ b/internal/doc/docir/ir.go
@@ -170,6 +170,7 @@ type Content struct {
 	items       []ListItem
 	definitions []Definition
 	rendering   *view.Rendering
+	sites       view.Sites
 	direction   view.Direction
 	palette     view.Palette
 	ports       view.Ports
@@ -257,6 +258,9 @@ func (c Content) Definitions() []Definition {
 // for every other kind.
 func (c Content) Rendering() *view.Rendering { return c.rendering.Clone() }
 
+// Sites returns the source locations diagrams in this content link to.
+func (c Content) Sites() view.Sites { return c.sites }
+
 // Direction returns the stated flow direction of a diagram, empty for the
 // kind's default.
 func (c Content) Direction() view.Direction { return c.direction }
@@ -308,6 +312,7 @@ func cloneContent(content []Content) []Content {
 			items:       child.Items(),
 			definitions: child.Definitions(),
 			rendering:   child.rendering.Clone(),
+			sites:       child.sites,
 			direction:   child.direction,
 			palette:     child.palette,
 			ports:       child.ports,
diff --git a/internal/doc/docpdf/docpdf.go b/internal/doc/docpdf/docpdf.go
index edee571d62..86934504d6 100644
--- a/internal/doc/docpdf/docpdf.go
+++ b/internal/doc/docpdf/docpdf.go
@@ -65,6 +65,9 @@ type Options struct {
 	// when empty.
 	Style view.DrawingStyle
 
+	// LinkTemplate fills source links for diagram elements.
+	LinkTemplate string
+
 	// TableColumns is the most columns one table is set with on a page: a
 	// table projecting more is split into continuation tables, each repeating
 	// the first column ahead of its share of the rest. 0 is DefaultTableColumns;
@@ -132,7 +135,7 @@ func Render(document *docir.Document, engine string, opts Options) ([]byte, erro
 	if err := converter.Available(); err != nil {
 		return nil, err
 	}
-	forms := docrender.DiagramOptions{Form: opts.DiagramForm, Unplaced: opts.Unplaced, Style: opts.Style}
+	forms := docrender.DiagramOptions{Form: opts.DiagramForm, Unplaced: opts.Unplaced, Style: opts.Style, LinkTemplate: opts.LinkTemplate}
 	forms.WithoutGraphviz = opts.DiagramForm == "" && !Graphviz{}.Available()
 	diagrams, err := docrender.Diagrams(document, forms)
 	if err != nil {
@@ -164,7 +167,7 @@ func Render(document *docir.Document, engine string, opts Options) ([]byte, erro
 	switch converter.Capabilities().Input {
 	case InputMarkdown:
 		markdown, err := docrender.Markdown(document, docrender.MarkdownOptions{
-			DiagramForm: opts.DiagramForm, WithoutGraphviz: forms.WithoutGraphviz, Unplaced: opts.Unplaced, Style: opts.Style,
+			DiagramForm: opts.DiagramForm, WithoutGraphviz: forms.WithoutGraphviz, Unplaced: opts.Unplaced, Style: opts.Style, LinkTemplate: opts.LinkTemplate,
 			OutputDir: base, NumberFigures: opts.NumberFigures, TableColumns: tableColumns(opts), TableMeasure: tableMeasure(opts),
 		})
 		if err != nil {
@@ -254,6 +257,7 @@ func htmlOptions(opts Options, withoutGraphviz bool, dir, base string, images []
 		WithoutGraphviz:     withoutGraphviz,
 		Unplaced:            opts.Unplaced,
 		Style:               opts.Style,
+		LinkTemplate:        opts.LinkTemplate,
 		DiagramImages:       images,
 		Math:                math.html,
 		OutputDir:           base,
diff --git a/internal/doc/docrender/artwork.go b/internal/doc/docrender/artwork.go
index e008448d6c..204b18f0c2 100644
--- a/internal/doc/docrender/artwork.go
+++ b/internal/doc/docrender/artwork.go
@@ -45,6 +45,9 @@ type DiagramOptions struct {
 	// Style is the drawing style every DOT or Mermaid diagram is drawn in, the
 	// Pilot look when empty; the other forms draw one look.
 	Style view.DrawingStyle
+
+	// LinkTemplate fills source links for diagram elements.
+	LinkTemplate string
 }
 
 // check rejects a form there is none of and a drawing style there is none of.
diff --git a/internal/doc/docrender/html.go b/internal/doc/docrender/html.go
index 594d39ef57..577fdc06b9 100644
--- a/internal/doc/docrender/html.go
+++ b/internal/doc/docrender/html.go
@@ -192,6 +192,9 @@ type HTMLOptions struct {
 	// when empty; the other forms draw one look.
 	Style view.DrawingStyle
 
+	// LinkTemplate fills source links for diagram elements. HTML content has no element-anchored sections.
+	LinkTemplate string
+
 	// Files is the file each document of the set this one is rendered in is
 	// written to, by qualified name; a cross-document reference links to the
 	// target's file here, or to DocumentHTMLFileName of its name when absent.
@@ -318,7 +321,7 @@ func (s Stylesheet) Check() error {
 
 // diagramOptions is the part of the options the diagrams are written by.
 func (o HTMLOptions) diagramOptions() DiagramOptions {
-	return DiagramOptions{Form: o.DiagramForm, WithoutGraphviz: o.WithoutGraphviz, Unplaced: o.Unplaced, Style: o.Style}
+	return DiagramOptions{Form: o.DiagramForm, WithoutGraphviz: o.WithoutGraphviz, Unplaced: o.Unplaced, Style: o.Style, LinkTemplate: o.LinkTemplate}
 }
 
 // htmlWriter accumulates one rendered document, its diagrams in the forms
diff --git a/internal/doc/docrender/html_test.go b/internal/doc/docrender/html_test.go
index e9f70ba829..1ce4a2ad17 100644
--- a/internal/doc/docrender/html_test.go
+++ b/internal/doc/docrender/html_test.go
@@ -67,6 +67,20 @@ func TestHTMLTelescopeReportGolden(t *testing.T) {
 	checkGolden(t, got, filepath.Join("testdata", "telescope_report.golden.html"))
 }
 
+func TestHTMLDiagramSourceLinks(t *testing.T) {
+	path := filepath.Join("testdata", "telescope_report.sysml")
+	got := renderFixtureHTML(t, path, "Observatory::MassReport", HTMLOptions{
+		DiagramForm:  view.FormMermaid,
+		LinkTemplate: "https://example.test/src/{file}#L{line}",
+	})
+	if !strings.Contains(got, `click n1 href &#34;https://example.test/src/telescope_report.sysml#L`) {
+		t.Errorf("HTML diagram does not link the source node:\n%s", got)
+	}
+	if strings.Contains(got, `securityLevel: 'loose'`) {
+		t.Errorf("HTML diagram link relaxed Mermaid security:\n%s", got)
+	}
+}
+
 // TestHTMLTelescopeReportFragmentGolden locks the fragment rendering with a
 // title page, a table of contents and numbered sections.
 func TestHTMLTelescopeReportFragmentGolden(t *testing.T) {
diff --git a/internal/doc/docrender/markdown.go b/internal/doc/docrender/markdown.go
index a5ed27dba5..92a650923e 100644
--- a/internal/doc/docrender/markdown.go
+++ b/internal/doc/docrender/markdown.go
@@ -39,6 +39,9 @@ type MarkdownOptions struct {
 	// when empty; the other forms draw one look.
 	Style view.DrawingStyle
 
+	// LinkTemplate fills source links for diagram elements.
+	LinkTemplate string
+
 	// Files is the file each document of the set this one is rendered in is
 	// written to, by qualified name; a cross-document reference links to the
 	// target's file here, or to DocumentFileName of its name when absent.
@@ -78,7 +81,7 @@ type MarkdownOptions struct {
 
 // diagramOptions is the part of the options the diagrams are written by.
 func (o MarkdownOptions) diagramOptions() DiagramOptions {
-	return DiagramOptions{Form: o.DiagramForm, WithoutGraphviz: o.WithoutGraphviz, Unplaced: o.Unplaced, Style: o.Style}
+	return DiagramOptions{Form: o.DiagramForm, WithoutGraphviz: o.WithoutGraphviz, Unplaced: o.Unplaced, Style: o.Style, LinkTemplate: o.LinkTemplate}
 }
 
 // Markdown renders an evaluated document as deterministic CommonMark: the
@@ -154,6 +157,7 @@ func figureOptions(node docir.Content, opts DiagramOptions) view.Options {
 	options := node.Options()
 	options.Unplaced = opts.Unplaced
 	options.Style = opts.Style
+	options.Links = view.Links{Template: opts.LinkTemplate, Sites: node.Sites()}
 	return options
 }
 
diff --git a/internal/doc/docrender/markdown_test.go b/internal/doc/docrender/markdown_test.go
index b37121108f..8725504b8e 100644
--- a/internal/doc/docrender/markdown_test.go
+++ b/internal/doc/docrender/markdown_test.go
@@ -58,6 +58,12 @@ func fixtureDocumentAt(t *testing.T, path, sourceName, name string) *docir.Docum
 	index.ExpandWildcardImports()
 	resolver := resolve.New(index)
 	model := passes.NewTypedModel(resolver)
+	model.SetSourceFile(func(doc string, _ source.Span) string {
+		if doc == sf.Name() {
+			return sourceName
+		}
+		return ""
+	})
 	model.SetSourceText(func(doc string, span source.Span) string {
 		if doc != sf.Name() {
 			return ""
@@ -72,7 +78,15 @@ func fixtureDocumentAt(t *testing.T, path, sourceName, name string) *docir.Docum
 	if err != nil {
 		t.Fatalf("compile document %s: %v", name, err)
 	}
-	document, err := docir.Evaluate(plan, queryexec.Context{Index: index, Resolver: resolver, Model: model}, queryexec.Options{}, nil)
+	document, err := docir.Evaluate(plan, queryexec.Context{
+		Index: index, Resolver: resolver, Model: model,
+		LineIndex: func(doc string) *source.LineIndex {
+			if doc == sf.Name() {
+				return sf.Lines()
+			}
+			return nil
+		},
+	}, queryexec.Options{}, nil)
 	if err != nil {
 		t.Fatalf("evaluate document %s: %v", name, err)
 	}
@@ -155,6 +169,21 @@ func TestMarkdownTelescopeReportDotGolden(t *testing.T) {
 	}
 }
 
+func TestMarkdownDiagramSourceLinks(t *testing.T) {
+	path := filepath.Join("testdata", "telescope_report.sysml")
+	document := fixtureDocument(t, path, "Observatory::MassReport")
+	got, err := Markdown(document, MarkdownOptions{
+		DiagramForm:  view.FormMermaid,
+		LinkTemplate: "https://example.test/src/{file}#L{line}",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(got, `click n1 href "https://example.test/src/telescope_report.sysml#L`) {
+		t.Errorf("Markdown diagram does not link the source node:\n%s", got)
+	}
+}
+
 // TestMarkdownTelescopeReportPlantUMLGolden locks the report with PlantUML
 // diagrams: the fences change, every other block matches the Mermaid golden.
 func TestMarkdownTelescopeReportPlantUMLGolden(t *testing.T) {
diff --git a/internal/doc/queryexec/execute.go b/internal/doc/queryexec/execute.go
index 881645c415..d9b64c3fa0 100644
--- a/internal/doc/queryexec/execute.go
+++ b/internal/doc/queryexec/execute.go
@@ -13,14 +13,16 @@ import (
 	"github.com/Open-MBEE/OpenSysML/internal/semantic/resolve"
 	"github.com/Open-MBEE/OpenSysML/internal/semantic/semantics"
 	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
 )
 
 // Context provides the semantic workspace used by one execution; Index,
 // Resolver and Model are required, Runtime and Roots absent over the model alone.
 type Context struct {
-	Index    *symbols.Index
-	Resolver *resolve.Resolver
-	Model    *semantics.Model
+	Index     *symbols.Index
+	Resolver  *resolve.Resolver
+	Model     *semantics.Model
+	LineIndex func(doc string) *source.LineIndex
 	// Runtime holds the objects the query may read; nil makes object bindings
 	// and Objects typed errors.
 	Runtime *runtime.Context
diff --git a/internal/frontend/lsp/document.go b/internal/frontend/lsp/document.go
index 6cd75ca4ce..836ae3f674 100644
--- a/internal/frontend/lsp/document.go
+++ b/internal/frontend/lsp/document.go
@@ -32,8 +32,9 @@ type documentInfo struct {
 // definition Name names. DiagramForm is the source its graph-shaped diagrams
 // are written as, mermaid, dot or plantuml; empty is mermaid.
 type renderDocumentParams struct {
-	Name        string `json:"name"`
-	DiagramForm string `json:"diagramForm,omitempty"`
+	Name         string `json:"name"`
+	DiagramForm  string `json:"diagramForm,omitempty"`
+	LinkTemplate string `json:"linkTemplate,omitempty"`
 }
 
 // renderDocumentResult is the rendered document.
@@ -58,7 +59,9 @@ func (s *Server) Documents() *documentsResult {
 // RenderDocument answers opensysml/renderDocument: the named document compiled,
 // evaluated and rendered as Markdown, or the typed error stopping it.
 func (s *Server) RenderDocument(params *renderDocumentParams) (*renderDocumentResult, error) {
-	opts := docrender.MarkdownOptions{DiagramForm: view.Form(params.DiagramForm), Drawer: docpdf.Graphviz{}}
+	opts := docrender.MarkdownOptions{
+		DiagramForm: view.Form(params.DiagramForm), Drawer: docpdf.Graphviz{}, LinkTemplate: params.LinkTemplate,
+	}
 	markdown, err := modeldoc.RenderDocumentMarkdown(s.ws, params.Name, opts)
 	if err != nil {
 		return nil, err
diff --git a/internal/frontend/lsp/document_test.go b/internal/frontend/lsp/document_test.go
index ac3b579018..8a1da890e5 100644
--- a/internal/frontend/lsp/document_test.go
+++ b/internal/frontend/lsp/document_test.go
@@ -2,6 +2,8 @@ package lsp
 
 import (
 	"context"
+	"encoding/json"
+	"path/filepath"
 	"strings"
 	"testing"
 
@@ -543,6 +545,27 @@ func TestRenderDocumentDiagramForm(t *testing.T) {
 	}
 }
 
+func TestRenderDocumentDiagramSourceLinks(t *testing.T) {
+	ws, s, _ := openDocumentModel(t)
+	name := uri.File("/tmp/imaging.sysml").Filename()
+	ws.Open(name, []byte(diagramDocumentModel), 1)
+	template := "https://example.test/src/{file}#L{line}:{col}"
+	raw, err := call(t, s, MethodRenderDocument, &renderDocumentParams{
+		Name: "Imaging::ChainReport", DiagramForm: "plantuml", LinkTemplate: template,
+	})
+	if err != nil {
+		t.Fatalf("render linked document: %v", err)
+	}
+	var out renderDocumentResult
+	if err := json.Unmarshal(raw, &out); err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(out.Markdown, "https://example.test/src/"+filepath.ToSlash(name)+"#L") ||
+		!strings.Contains(out.Markdown, "[[") {
+		t.Errorf("document diagram lacks source links:\n%s", out.Markdown)
+	}
+}
+
 func TestRenderDocumentTypedErrors(t *testing.T) {
 	_, s, _ := openDocumentModel(t)
 	if _, err := s.RenderDocument(&renderDocumentParams{Name: "Observatory::Subsystem"}); err == nil ||
diff --git a/internal/frontend/lsp/render.go b/internal/frontend/lsp/render.go
index 2e6ba11676..f8e1e397ec 100644
--- a/internal/frontend/lsp/render.go
+++ b/internal/frontend/lsp/render.go
@@ -94,6 +94,7 @@ type renderParams struct {
 	Palette      string                          `json:"palette,omitempty"`
 	Style        string                          `json:"style,omitempty"`
 	Ports        string                          `json:"ports,omitempty"`
+	LinkTemplate string                          `json:"linkTemplate,omitempty"`
 }
 
 // renderResult is one rendering: the artifact a client draws, plus the nodes and
@@ -315,7 +316,14 @@ func (s *Server) Views(params *viewsParams) *viewsResult {
 // workspace the rendering was made under.
 func (s *Server) Render(params *renderParams) (*renderResult, error) {
 	name := uriToName(params.TextDocument.URI)
-	rendering, snapshot, err := s.ws.RenderView(name, params.View)
+	var rendering *view.Rendering
+	var snapshot *model.Snapshot
+	var err error
+	if params.LinkTemplate != "" {
+		rendering, snapshot, err = s.ws.RenderViewLinked(name, params.View)
+	} else {
+		rendering, snapshot, err = s.ws.RenderView(name, params.View)
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -337,7 +345,10 @@ func (s *Server) Render(params *renderParams) (*renderResult, error) {
 	if err != nil {
 		return nil, err
 	}
-	artifact, err := rendering.WriteWith(form, view.Options{Palette: colors, Style: style, Ports: ports})
+	artifact, err := rendering.WriteWith(form, view.Options{
+		Palette: colors, Style: style, Ports: ports,
+		Links: view.Links{Template: params.LinkTemplate, Sites: snapshot.Sites()},
+	})
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/frontend/lsp/render_test.go b/internal/frontend/lsp/render_test.go
index 36d728a42c..abf02e37e6 100644
--- a/internal/frontend/lsp/render_test.go
+++ b/internal/frontend/lsp/render_test.go
@@ -176,10 +176,15 @@ func call(t *testing.T, s *Server, method string, params any) (json.RawMessage,
 
 // render is one opensysml/render request, decoded.
 func render(t *testing.T, s *Server, docURI uri.URI, viewName string) *renderResult {
+	return renderWithLinkTemplate(t, s, docURI, viewName, "")
+}
+
+func renderWithLinkTemplate(t *testing.T, s *Server, docURI uri.URI, viewName, template string) *renderResult {
 	t.Helper()
 	raw, err := call(t, s, MethodRender, &renderParams{
 		TextDocument: protocol.TextDocumentIdentifier{URI: docURI},
 		View:         viewName,
+		LinkTemplate: template,
 	})
 	if err != nil {
 		t.Fatalf("render %q: %v", viewName, err)
@@ -191,6 +196,31 @@ func render(t *testing.T, s *Server, docURI uri.URI, viewName string) *renderRes
 	return &out
 }
 
+func TestRenderWritesSourceLinks(t *testing.T) {
+	s, docURI := renderServer(t, "kit.sysml", renderModel)
+	template := "https://example.test/src/{file}#L{line}:{col}"
+	params, err := json.Marshal(renderParams{
+		TextDocument: protocol.TextDocumentIdentifier{URI: docURI},
+		View:         "KitViews::widgetTree",
+		LinkTemplate: template,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var wire map[string]any
+	if err := json.Unmarshal(params, &wire); err != nil {
+		t.Fatal(err)
+	}
+	if wire["linkTemplate"] != template {
+		t.Errorf("wire linkTemplate = %v, want %q", wire["linkTemplate"], template)
+	}
+	out := renderWithLinkTemplate(t, s, docURI, "KitViews::widgetTree", template)
+	if !strings.Contains(out.Artifact, `click n0 href "https://example.test/src/`) ||
+		!strings.Contains(out.Artifact, "#L") {
+		t.Errorf("render artifact lacks source links:\n%s", out.Artifact)
+	}
+}
+
 // Every rendering kind this package produces is served over the protocol, with
 // the artifact a client draws and the nodes it is made of.
 func TestRenderServesEverySupportedKind(t *testing.T) {
diff --git a/internal/frontend/repl/docquery.go b/internal/frontend/repl/docquery.go
index 9062afe959..dc6ad4b8a1 100644
--- a/internal/frontend/repl/docquery.go
+++ b/internal/frontend/repl/docquery.go
@@ -11,6 +11,7 @@ import (
 	"github.com/Open-MBEE/OpenSysML/internal/ir/queryplan"
 	"github.com/Open-MBEE/OpenSysML/internal/semantic/semantics"
 	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
 )
 
 // runQueryUsage is what %run-query accepts: a document query's name and its
@@ -185,12 +186,21 @@ func (s *Session) queryContext(ctx *runtime.Context) queryexec.Context {
 	for _, root := range carriers {
 		roots = append(roots, queryexec.Root{Label: root.name, Object: root.inst})
 	}
+	lineIndexes := make(map[string]*source.LineIndex)
+	for _, document := range s.sessionDocs() {
+		if document.Name != docName {
+			lineIndexes[document.Name] = document.Lines()
+		}
+	}
 	return queryexec.Context{
 		Index:    s.browseIndex(),
 		Resolver: ctx.Resolver(),
 		Model:    ctx.Semantics(),
 		Runtime:  ctx,
 		Roots:    roots,
+		LineIndex: func(doc string) *source.LineIndex {
+			return lineIndexes[doc]
+		},
 	}
 }
 
diff --git a/internal/frontend/repl/meta.go b/internal/frontend/repl/meta.go
index 6d2adef4a2..2baafeb748 100644
--- a/internal/frontend/repl/meta.go
+++ b/internal/frontend/repl/meta.go
@@ -29,7 +29,7 @@ import (
 
 // renderUsage is how %render is written: a view, the form to write it in, text
 // when none is named, then a palette, style and port display the form draws.
-const renderUsage = "usage: %render <name> [text|mermaid|markdown|dot|plantuml|csv|tsv [palette] [pilot|cameo] [minimal|full]]"
+const renderUsage = "usage: %render <name> [text|mermaid|markdown|dot|plantuml|csv|tsv [palette] [pilot|cameo] [minimal|full] [link=<template>]]"
 
 // isMeta reports whether a trimmed input line is a meta command.
 func isMeta(line string) bool {
@@ -214,7 +214,7 @@ var metaCommandTable = []metaCommand{
 	{name: "%search", group: groupLibrary, args: "<substring>", desc: "list the declared and library symbols whose qualified name contains <substring>"},
 	{name: "%builtins", group: groupLibrary, desc: "list the library functions this build implements directly"},
 	{name: "%view", group: groupLibrary, args: argName, desc: "show what a view exposes, and the views nested in it"},
-	{name: "%render", group: groupLibrary, args: "<name> [form [palette] [style] [ports]]", desc: "render a view as the rendering it states — as text, as a Mermaid diagram or a Markdown table, or as Graphviz DOT or PlantUML, filled from a named palette and drawn in a style (pilot or cameo)"},
+	{name: "%render", group: groupLibrary, args: "<name> [form [palette] [style] [ports] [link=<template>]]", desc: "render a view as the rendering it states, optionally linking elements to their source with a link template"},
 
 	{name: "%instantiate", group: groupRuntime, args: argName, desc: "create an instance of a part def"},
 	{name: "%eval", group: groupRuntime, args: "[in <name>|<path>|#<id> :] <expr>", desc: "evaluate an expression, in the named element or object when one is named"},
@@ -487,11 +487,10 @@ func (s *Session) doTrace(args []string) []string {
 	return []string{fmt.Sprintf("trace: %s", onOff(s.trace != nil))}
 }
 
-// metaRender reads the %render arguments — the name, an optional form, an
-// optional port display and, for a form that fills nodes, an optional palette
-// and drawing style — and renders the view they name.
+// metaRender reads the %render name, form and optional rendering settings,
+// including a source-link template, then renders the view they name.
 func (s *Session) metaRender(args []string) ([]string, bool, error) {
-	if len(args) < 1 || len(args) > 5 {
+	if len(args) < 1 || len(args) > 6 {
 		return []string{renderUsage}, false, nil
 	}
 	form := view.FormText
@@ -502,7 +501,19 @@ func (s *Session) metaRender(args []string) ([]string, bool, error) {
 		}
 	}
 	var opts view.Options
+	linkSet := false
 	for _, word := range args[min(2, len(args)):] {
+		if strings.HasPrefix(word, "link=") {
+			if linkSet {
+				return []string{renderUsage}, false, nil
+			}
+			opts.Links.Template = strings.TrimPrefix(word, "link=")
+			if err := view.ParseLinkTemplate(opts.Links.Template); err != nil {
+				return []string{err.Error() + "; " + renderUsage}, false, nil
+			}
+			linkSet = true
+			continue
+		}
 		if style, ok := view.ParseDrawingStyle(word); ok {
 			if opts.Style != "" {
 				return []string{renderUsage}, false, nil
diff --git a/internal/frontend/repl/view.go b/internal/frontend/repl/view.go
index 3ac4d05a4c..1be940f9e4 100644
--- a/internal/frontend/repl/view.go
+++ b/internal/frontend/repl/view.go
@@ -126,9 +126,57 @@ func (s *Session) renderLines(name string, form view.Form, opts view.Options) ([
 		return nil, err
 	}
 	opts.Width = s.renderWidth
+	if opts.Links.Template != "" {
+		renderer, err := s.viewRenderer()
+		if err != nil {
+			return nil, err
+		}
+		opts.Links.Sites = renderer.Sites(s.sessionLocator())
+	}
 	return artifactLines(rendering, form, opts)
 }
 
+// ViewSites answers source locations in the current session for a rendering.
+func (s *Session) ViewSites() (view.Sites, error) {
+	defer s.enter()()
+	renderer, err := s.viewRenderer()
+	if err != nil {
+		return nil, err
+	}
+	return renderer.Sites(s.sessionLocator()), nil
+}
+
+func (s *Session) sessionLocator() view.Locator {
+	indexes := map[int]*source.LineIndex{}
+	return func(origin view.Origin) (string, source.Pos, bool) {
+		if !origin.Located() {
+			return "", source.Pos{}, false
+		}
+		file := s.sessionSourceFile(origin.Doc, origin.Span)
+		if file == "" {
+			return "", source.Pos{}, false
+		}
+		if origin.Doc == docName {
+			sn, start := s.snippetAt(origin.Span.Offset)
+			if sn.origin == "" {
+				return "", source.Pos{}, false
+			}
+			lines := indexes[start]
+			if lines == nil {
+				lines = source.NewLineIndex([]byte(sn.src))
+				indexes[start] = lines
+			}
+			return file, lines.PosAt(origin.Span.Offset - start), true
+		}
+		for _, doc := range s.sessionDocs() {
+			if doc.Name == origin.Doc {
+				return file, doc.Lines().PosAt(origin.Span.Offset), true
+			}
+		}
+		return "", source.Pos{}, false
+	}
+}
+
 // artifactLines writes a rendering in form, one line per line, and under a
 // delimited form its notices after the records, which carry none.
 func artifactLines(rendering *view.Rendering, form view.Form, opts view.Options) ([]string, error) {
diff --git a/internal/frontend/repl/view_render_test.go b/internal/frontend/repl/view_render_test.go
index dbcb52620b..7210f447c9 100644
--- a/internal/frontend/repl/view_render_test.go
+++ b/internal/frontend/repl/view_render_test.go
@@ -2,6 +2,7 @@ package repl
 
 import (
 	"errors"
+	"path/filepath"
 	"slices"
 	"strings"
 	"testing"
@@ -45,6 +46,29 @@ func TestRenderWritesMermaidWhenAskedFor(t *testing.T) {
 	}
 }
 
+func TestRenderLinksUseLoadedSourcePositions(t *testing.T) {
+	dir := t.TempDir()
+	path := writeFile(t, filepath.Join(dir, "linked.sysml"), `package Linked {
+    part def Cog;
+    view overview { expose Linked::Cog; }
+}
+`)
+	s := NewSession()
+	if _, err := s.LoadFilesSummary([]string{path}); err != nil {
+		t.Fatal(err)
+	}
+	template := "https://example.test/src/{file}#L{line}:{col}"
+	got := run(t, s, "%render Linked::overview mermaid link="+template)
+	want := `click n0 href "https://example.test/src/` + filepath.ToSlash(path) + `#L2:`
+	if !strings.Contains(got, want) {
+		t.Errorf("REPL rendering lacks source link %q:\n%s", want, got)
+	}
+	wants(t, run(t, s, "%render Linked::overview mermaid link=https://example.test/{unknown}"),
+		"unknown link template placeholder {unknown}")
+	wants(t, run(t, s, "%render Linked::overview mermaid link=https://example.test/{file} link=https://example.test/{line}"),
+		renderUsage)
+}
+
 // The DOT form is asked for by name, is the same rendering as a digraph, and is
 // offered by the usage and help text.
 func TestRenderWritesDotWhenAskedFor(t *testing.T) {
@@ -69,9 +93,9 @@ func TestRenderWritesDotWhenAskedFor(t *testing.T) {
 	if strings.Contains(text, "flowchart") || strings.Contains(text, `fillcolor="#`) {
 		t.Errorf("%%render dot wrote Mermaid or a palette:\n%s", text)
 	}
-	wants(t, run(t, s, "%render"), "usage: %render <name> [text|mermaid|markdown|dot|plantuml|csv|tsv [palette] [pilot|cameo] [minimal|full]]")
-	wants(t, run(t, s, "%render Demo::summary svg"), `unknown form "svg"`, "[text|mermaid|markdown|dot|plantuml|csv|tsv [palette] [pilot|cameo] [minimal|full]]")
-	wants(t, run(t, s, "%help"), "%render <name> [form [palette] [style] [ports]]", "Graphviz DOT", "PlantUML")
+	wants(t, run(t, s, "%render"), renderUsage)
+	wants(t, run(t, s, "%render Demo::summary svg"), `unknown form "svg"`, renderUsage)
+	wants(t, run(t, s, "%help"), "%render <name> [form [palette] [style] [ports] [link=<template>]]", "Graphviz DOT", "PlantUML")
 }
 
 // The PlantUML form is asked for by name, is the same rendering in PlantUML
@@ -133,10 +157,10 @@ func TestRenderDotTakesAPalette(t *testing.T) {
 	}
 	wants(t, run(t, s, "%render Demo::summary dot rainbow"),
 		`unknown palette "rainbow"; the palettes are okabe-ito, tol-bright, tol-muted, tol-light, brewer-set2, brewer-dark2, viridis, cividis`,
-		"usage: %render <name> [text|mermaid|markdown|dot|plantuml|csv|tsv [palette] [pilot|cameo] [minimal|full]]")
+		renderUsage)
 	wants(t, run(t, s, "%render Demo::summary mermaid okabe-ito"), "classDef palette0 fill:#")
 	wants(t, run(t, s, "%render Demo::summary text okabe-ito"), "a palette fills the mermaid, dot and plantuml forms only, not text")
-	wants(t, run(t, s, "%render Demo::summary dot okabe-ito cameo extra"), "usage: %render <name> [text|mermaid|markdown|dot|plantuml|csv|tsv [palette] [pilot|cameo] [minimal|full]]")
+	wants(t, run(t, s, "%render Demo::summary dot okabe-ito cameo extra"), renderUsage)
 	if got := s.Complete("%render Demo::summary dot ", len("%render Demo::summary dot ")); !slices.Contains(got.Candidates, "okabe-ito") || !slices.Contains(got.Candidates, "viridis") {
 		t.Errorf("completing the palette offered %v", got.Candidates)
 	}
diff --git a/internal/ir/view/dot.go b/internal/ir/view/dot.go
index 774ffed652..3fe247f5b9 100644
--- a/internal/ir/view/dot.go
+++ b/internal/ir/view/dot.go
@@ -245,7 +245,7 @@ func newDOTWriter(r *Rendering, options Options) *dotWriter {
 	skin := skinOf(options.Style)
 	w := &dotWriter{tree: r.Kind == KindTree, action: r.Kind == KindAction, clusters: map[string]bool{}, enclosing: map[string][]string{}, canvas: r.Canvas,
 		placement: placeRendering(r), drawn: map[string]bool{}, boxes: map[string]nodeBox{}, pins: map[string]nodeBox{}, ported: map[string]*Node{}, omitted: map[string]bool{},
-		fills: familyFills{palette: options.Palette, tree: r.Kind == KindTree}, skin: skin, pictures: r.Pictures}
+		fills: familyFills{palette: options.Palette, tree: r.Kind == KindTree}, skin: skin, pictures: r.Pictures, links: options.Links}
 	w.sources = map[string]bool{}
 	for _, edge := range r.Edges {
 		if edge.FromPort != "" {
@@ -457,11 +457,12 @@ type dotWriter struct {
 	fills     familyFills         // the palette fills, by keyword family
 	labels    labeller            // the node labels, headed relative to the roots' namespace
 	skin      dotSkin             // the drawing style's defaults
-	notes     []Note              // the notes the drawing keeps, those of the nodes it draws
-	noteBoxes []nodeBox           // where each positioned note is drawn, by index in notes
-	noteShown []int               // note index -> the index of the note drawn for it, itself unless a twin at the same place is
-	pictures  []Picture           // the pictures drawn, each at its stated bounds
-	frameRoot string              // the root the Cameo frame header names, drawn untitled
+	links     Links
+	notes     []Note    // the notes the drawing keeps, those of the nodes it draws
+	noteBoxes []nodeBox // where each positioned note is drawn, by index in notes
+	noteShown []int     // note index -> the index of the note drawn for it, itself unless a twin at the same place is
+	pictures  []Picture // the pictures drawn, each at its stated bounds
+	frameRoot string    // the root the Cameo frame header names, drawn untitled
 }
 
 // The Standard B&W style, after the sysmlbw PlantUML skin: Helvetica text,
@@ -1133,6 +1134,7 @@ func (w *dotWriter) dotNodeAttributes(node *Node) []string {
 			attrs = append(attrs, `comment="collapsed"`)
 		}
 	}
+	attrs = append(attrs, w.dotLinkAttributes(node.Origin)...)
 	return attrs
 }
 
@@ -1677,6 +1679,19 @@ func (w *dotWriter) dotAnchorAttributes(node *Node) []string {
 	return attrs
 }
 
+func (w *dotWriter) dotLinkAttributes(origin Origin) []string {
+	url, ok := w.links.URL(origin)
+	if !ok {
+		return nil
+	}
+	site, _ := w.links.Sites(origin)
+	tooltip := site.QualifiedName
+	if tooltip == "" {
+		tooltip = fmt.Sprintf("%s:%d:%d", site.File, site.Line, site.Col)
+	}
+	return []string{"URL=" + dotQuote(url), "tooltip=" + dotQuote(tooltip)}
+}
+
 // 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=""`}
 
@@ -1703,6 +1718,7 @@ func (w *dotWriter) dotClusterAttributes(node *Node) []string {
 	if g := node.Geometry; g != nil && g.Collapsed {
 		attrs = append(attrs, `comment="collapsed"`)
 	}
+	attrs = append(attrs, w.dotLinkAttributes(node.Origin)...)
 	return attrs
 }
 
@@ -1809,6 +1825,7 @@ func (w *dotWriter) dotEdgeAttributes(edge Edge) []string {
 			attrs = append(attrs, "lp="+dotQuote(w.dotPoint(w.dotLabelPoint(edge))))
 		}
 	}
+	attrs = append(attrs, w.dotLinkAttributes(edge.Origin)...)
 	return attrs
 }
 
diff --git a/internal/ir/view/form.go b/internal/ir/view/form.go
index 675907ec9e..c1dccc1bb0 100644
--- a/internal/ir/view/form.go
+++ b/internal/ir/view/form.go
@@ -148,6 +148,8 @@ func (e *WrongFormError) Unwrap() error { return ErrWrongForm }
 // PlantUML their Direction, Palette, Style and Unplaced, and the interconnection
 // forms their Ports display. A form ignores the rest.
 type Options struct {
+	// Links is the source link each node and edge is written with; zero writes none.
+	Links Links
 	// Direction is the flow direction a graph-shaped form is drawn in; empty
 	// leaves each kind's default.
 	Direction Direction
@@ -179,6 +181,11 @@ func (r *Rendering) Write(form Form) (string, error) {
 // on every form that fills nodes, and a port display outside it an
 // *UnknownPortsError on every form.
 func (r *Rendering) WriteWith(form Form, options Options) (string, error) {
+	if options.Links.Template != "" {
+		if err := ParseLinkTemplate(options.Links.Template); err != nil {
+			return "", err
+		}
+	}
 	if err := options.Ports.check(); err != nil {
 		return "", err
 	}
diff --git a/internal/ir/view/links.go b/internal/ir/view/links.go
new file mode 100644
index 0000000000..7a8248cb4c
--- /dev/null
+++ b/internal/ir/view/links.go
@@ -0,0 +1,200 @@
+package view
+
+import (
+	"fmt"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/identity"
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/semantics"
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
+)
+
+// Site is where a rendered element was declared, the values a link template fills.
+type Site struct {
+	File          string
+	Line, Col     int
+	QualifiedName string
+	ID            string
+}
+
+// Locator places a located origin in its source file; ok is false when no
+// on-disk source location is available.
+type Locator func(Origin) (file string, pos source.Pos, ok bool)
+
+// Sites answers the Site of an origin; false links nothing.
+type Sites func(Origin) (Site, bool)
+
+// Links is a link template and its source sites; the zero value writes none.
+type Links struct {
+	Template string
+	Sites    Sites
+}
+
+// Enabled reports whether links have both a template and source locations.
+func (l Links) Enabled() bool { return l.Template != "" && l.Sites != nil }
+
+// URL fills the template for a located origin.
+func (l Links) URL(o Origin) (string, bool) {
+	if !o.Located() || !l.Enabled() {
+		return "", false
+	}
+	if ParseLinkTemplate(l.Template) != nil {
+		return "", false
+	}
+	site, ok := l.Sites(o)
+	if !ok {
+		return "", false
+	}
+	return fillLinkTemplate(l.Template, site), true
+}
+
+// ParseLinkTemplate rejects unknown placeholders and an unclosed opening brace.
+func ParseLinkTemplate(template string) error {
+	for i := 0; i < len(template); {
+		if template[i] != '{' {
+			i++
+			continue
+		}
+		end := strings.IndexByte(template[i+1:], '}')
+		if end < 0 {
+			return fmt.Errorf("unclosed { in link template")
+		}
+		name := template[i+1 : i+1+end]
+		switch name {
+		case "file", "line", "col", "qname", "id":
+		default:
+			return fmt.Errorf("unknown link template placeholder {%s}", name)
+		}
+		i += end + 2
+	}
+	return nil
+}
+
+// Sites resolves origins to files and memoizes each located result.
+func (r *Renderer) Sites(locate Locator) Sites {
+	type result struct {
+		site Site
+		ok   bool
+	}
+	cache := map[Origin]result{}
+	var mu sync.Mutex
+	return func(origin Origin) (Site, bool) {
+		if !origin.Located() || locate == nil {
+			return Site{}, false
+		}
+		mu.Lock()
+		defer mu.Unlock()
+		if found, ok := cache[origin]; ok {
+			return found.site, found.ok
+		}
+		file, pos, ok := locate(origin)
+		if !ok || file == "" {
+			cache[origin] = result{}
+			return Site{}, false
+		}
+		site := Site{File: filepath.ToSlash(file), Line: pos.Line, Col: pos.Col}
+		if r != nil && r.resolver != nil && r.model != nil {
+			if index := r.resolver.Index(); index != nil {
+				if scope := index.DocumentRoot(origin.Doc); scope != nil {
+					if sym := scope.DeclaredAt(origin.Span); sym != nil {
+						if sym.Name != "" {
+							site.QualifiedName = source.QualifiedNameOf(symbols.NameChain(sym))
+						}
+						if info, ok := identity.Of(r.model, r.resolver, sym); ok && info != nil {
+							site.ID = info.EffectiveID
+						}
+					}
+				}
+			}
+		}
+		cache[origin] = result{site: site, ok: true}
+		return site, true
+	}
+}
+
+// FileLocator locates origins in source files and maps their byte offsets to positions.
+func FileLocator(model *semantics.Model, lines func(doc string) *source.LineIndex) Locator {
+	return func(origin Origin) (string, source.Pos, bool) {
+		if !origin.Located() || model == nil || lines == nil {
+			return "", source.Pos{}, false
+		}
+		file := model.SourceFileOf(origin)
+		lineIndex := lines(origin.Doc)
+		if file == "" || lineIndex == nil {
+			return "", source.Pos{}, false
+		}
+		return filepath.ToSlash(file), lineIndex.PosAt(origin.Span.Offset), true
+	}
+}
+
+func fillLinkTemplate(template string, site Site) string {
+	var out strings.Builder
+	for i := 0; i < len(template); {
+		if template[i] != '{' {
+			start := i
+			for i < len(template) && template[i] != '{' {
+				i++
+			}
+			out.WriteString(encodeLinkLiteral(template[start:i]))
+			continue
+		}
+		end := strings.IndexByte(template[i+1:], '}')
+		if end < 0 {
+			return ""
+		}
+		name := template[i+1 : i+1+end]
+		value := ""
+		switch name {
+		case "file":
+			value = site.File
+		case "line":
+			value = strconv.Itoa(site.Line)
+		case "col":
+			value = strconv.Itoa(site.Col)
+		case "qname":
+			value = site.QualifiedName
+		case "id":
+			value = site.ID
+		}
+		out.WriteString(encodeLinkValue(value))
+		i += end + 2
+	}
+	return out.String()
+}
+
+func encodeLinkValue(value string) string {
+	return percentEncode(value, func(b byte) bool {
+		return isLinkUnreserved(b) || b == '/' || b == ':'
+	})
+}
+
+func encodeLinkLiteral(value string) string {
+	return percentEncode(value, func(b byte) bool {
+		return b >= 0x21 && b < 0x7f && !strings.ContainsRune(`"<>\\^`+"`"+`{}|[]`, rune(b))
+	})
+}
+
+func percentEncode(value string, allowed func(byte) bool) string {
+	var out strings.Builder
+	const hex = "0123456789ABCDEF"
+	for i := 0; i < len(value); i++ {
+		b := value[i]
+		if allowed(b) {
+			out.WriteByte(b)
+		} else {
+			out.WriteByte('%')
+			out.WriteByte(hex[b>>4])
+			out.WriteByte(hex[b&0xf])
+		}
+	}
+	return out.String()
+}
+
+func isLinkUnreserved(b byte) bool {
+	return b >= 'A' && b <= 'Z' || b >= 'a' && b <= 'z' ||
+		b >= '0' && b <= '9' || strings.ContainsRune("-._~", rune(b))
+}
diff --git a/internal/ir/view/links_test.go b/internal/ir/view/links_test.go
new file mode 100644
index 0000000000..718bc3c7b0
--- /dev/null
+++ b/internal/ir/view/links_test.go
@@ -0,0 +1,839 @@
+package view
+
+import (
+	"bytes"
+	"encoding/xml"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/identity"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
+)
+
+func TestParseLinkTemplate(t *testing.T) {
+	for _, template := range []string{
+		"https://example.com/{file}#L{line}:{col}?name={qname}&id={id}",
+		"",
+	} {
+		if err := ParseLinkTemplate(template); err != nil {
+			t.Errorf("ParseLinkTemplate(%q) = %v", template, err)
+		}
+	}
+	for _, template := range []string{"https://example.com/{unknown}", "https://example.com/{"} {
+		if err := ParseLinkTemplate(template); err == nil {
+			t.Errorf("ParseLinkTemplate(%q) succeeded", template)
+		}
+	}
+}
+
+func TestLinkURLPercentEncodesSubstitutionsAndLiteralDelimiters(t *testing.T) {
+	site := Site{
+		File:          `dir/a b]\"#{}%é漢.sysml`,
+		Line:          7,
+		Col:           11,
+		QualifiedName: `Pkg::'Pum p]\"#{}%é漢'`,
+		ID:            `id /:#?&%é漢`,
+	}
+	links := Links{
+		Template: "https://example.com/src/{file}#L{line}:{col}?name={qname}&id={id}%#?'[]",
+		Sites: func(Origin) (Site, bool) {
+			return site, true
+		},
+	}
+	got, ok := links.URL(Origin{Doc: "model.sysml", Span: source.Span{Offset: 1, Len: 1}})
+	if !ok {
+		t.Fatal("URL returned no link")
+	}
+	want := "https://example.com/src/dir/a%20b%5D%5C%22%23%7B%7D%25%C3%A9%E6%BC%A2.sysml#L7:11?name=Pkg::%27Pum%20p%5D%5C%22%23%7B%7D%25%C3%A9%E6%BC%A2%27&id=id%20/:%23%3F%26%25%C3%A9%E6%BC%A2%#?'%5B%5D"
+	if got != want {
+		t.Errorf("URL = %q, want %q", got, want)
+	}
+	for _, forbidden := range []string{` `, `"`, `\`, `]`, `{`, `}`} {
+		if strings.Contains(got, forbidden) {
+			t.Errorf("URL contains forbidden %q: %s", forbidden, got)
+		}
+	}
+}
+
+func TestLinksDeclineUnlocatedAndMissingSites(t *testing.T) {
+	located := Origin{Doc: "model.sysml", Span: source.Span{Offset: 1, Len: 1}}
+	for name, links := range map[string]Links{
+		"zero origin":  {Template: "https://example.com/{file}", Sites: func(Origin) (Site, bool) { return Site{}, true }},
+		"nil sites":    {Template: "https://example.com/{file}"},
+		"site miss":    {Template: "https://example.com/{file}", Sites: func(Origin) (Site, bool) { return Site{}, false }},
+		"bad template": {Template: "https://example.com/{unknown}", Sites: func(Origin) (Site, bool) { return Site{}, true }},
+	} {
+		t.Run(name, func(t *testing.T) {
+			origin := located
+			if name == "zero origin" {
+				origin = Origin{}
+			}
+			if url, ok := links.URL(origin); ok || url != "" {
+				t.Errorf("URL = %q, %t; want no link", url, ok)
+			}
+		})
+	}
+}
+
+func TestRendererSitesMemoizesAndUsesEffectiveIdentity(t *testing.T) {
+	renderer, idx := loadFixtures(t, "tree.sysml")
+	rendering, err := renderer.Render(lookup(t, idx, "VehicleViews::vehicleView"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	origin := rendering.Roots[0].Origin
+	calls := 0
+	sites := renderer.Sites(func(got Origin) (string, source.Pos, bool) {
+		calls++
+		if got != origin {
+			t.Errorf("locator origin = %+v, want %+v", got, origin)
+		}
+		return filepath.Join("workspace", got.Doc), source.Pos{Line: 3, Col: 5}, true
+	})
+	first, ok := sites(origin)
+	if !ok {
+		t.Fatal("Sites returned no source site")
+	}
+	second, ok := sites(origin)
+	if !ok {
+		t.Fatal("memoized Sites returned no source site")
+	}
+	if calls != 1 {
+		t.Errorf("locator called %d times, want once per origin", calls)
+	}
+	if first != second {
+		t.Errorf("memoized site = %+v, want %+v", second, first)
+	}
+	if first.File != "workspace/tree.sysml" || first.Line != 3 || first.Col != 5 {
+		t.Errorf("site = %+v, want slash-normalized file and source position", first)
+	}
+	if first.QualifiedName == "" {
+		t.Error("site has no qualified name")
+	}
+	sym := renderer.resolver.Index().DocumentRoot(origin.Doc).DeclaredAt(origin.Span)
+	info, hasIdentity := identity.Of(renderer.model, renderer.resolver, sym)
+	if !hasIdentity || info == nil {
+		t.Fatal("identity.Of returned no effective identity for the rendered declaration")
+	}
+	if first.ID != info.EffectiveID {
+		t.Errorf("ID = %q, want effective identity %q", first.ID, info.EffectiveID)
+	}
+}
+
+func TestRendererSitesMemoizesConcurrentLookups(t *testing.T) {
+	renderer, index := loadFixtures(t, "tree.sysml")
+	rendering, err := renderer.Render(lookup(t, index, "VehicleViews::vehicleView"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	origin := rendering.Roots[0].Origin
+	var calls atomic.Int32
+	sites := renderer.Sites(func(got Origin) (string, source.Pos, bool) {
+		calls.Add(1)
+		return got.Doc, source.Pos{Line: 1, Col: 1}, true
+	})
+
+	var workers sync.WaitGroup
+	for range 16 {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			if _, ok := sites(origin); !ok {
+				t.Error("Sites returned no source site")
+			}
+		}()
+	}
+	workers.Wait()
+	if calls.Load() != 1 {
+		t.Errorf("locator called %d times, want once for concurrent lookups", calls.Load())
+	}
+}
+
+func TestRendererSitesLeaveAnonymousQualifiedNameEmpty(t *testing.T) {
+	renderer, index := loadFixtures(t, "interconnection.sysml")
+	rendering, err := renderer.Render(lookup(t, index, "PlantViews::loopView"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var origin Origin
+	for _, edge := range rendering.Edges {
+		if edge.Kind == EdgeFlow {
+			origin = edge.Origin
+			break
+		}
+	}
+	if !origin.Located() {
+		t.Fatal("flow edge has no located origin")
+	}
+	sites := renderer.Sites(func(got Origin) (string, source.Pos, bool) {
+		return got.Doc, source.Pos{Line: 20, Col: 3}, true
+	})
+	site, ok := sites(origin)
+	if !ok {
+		t.Fatal("Sites returned no source site for the anonymous flow")
+	}
+	if site.QualifiedName != "" {
+		t.Errorf("anonymous flow qualified name = %q, want empty", site.QualifiedName)
+	}
+	artifact, err := rendering.WriteWith(FormDot, Options{Links: Links{
+		Template: "https://example.test/{file}#L{line}:{col}",
+		Sites:    sites,
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want := `tooltip="interconnection.sysml:20:3"`; !strings.Contains(artifact, want) {
+		t.Errorf("anonymous flow tooltip does not fall back to its source position %q:\n%s", want, artifact)
+	}
+}
+
+func TestFileLocatorRequiresOnDiskFileAndLineIndex(t *testing.T) {
+	renderer, idx := loadFixtures(t, "tree.sysml")
+	rendering, err := renderer.Render(lookup(t, idx, "VehicleViews::vehicleView"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	origin := rendering.Roots[0].Origin
+	lineIndex := fixtureText(t, "tree.sysml").Lines()
+	locator := FileLocator(renderer.model, func(doc string) *source.LineIndex {
+		if doc != origin.Doc {
+			t.Errorf("line index requested for %q, want %q", doc, origin.Doc)
+		}
+		return lineIndex
+	})
+	file, pos, ok := locator(origin)
+	if !ok || file != origin.Doc || pos != lineIndex.PosAt(origin.Span.Offset) {
+		t.Errorf("FileLocator = %q, %+v, %t", file, pos, ok)
+	}
+	if _, _, ok := FileLocator(renderer.model, nil)(origin); ok {
+		t.Error("FileLocator succeeded without line index")
+	}
+	renderer.model.SetSourceFile(func(string, source.Span) string { return "" })
+	if _, _, ok := FileLocator(renderer.model, func(string) *source.LineIndex {
+		return lineIndex
+	})(origin); ok {
+		t.Error("FileLocator succeeded without an on-disk source file")
+	}
+}
+
+func TestWriteWithNoSitesIsByteIdentical(t *testing.T) {
+	cases := []struct {
+		file, name string
+	}{
+		{"interconnection.sysml", "PlantViews::loopView"},
+		{"tree.sysml", "VehicleViews::vehicleView"},
+		{"state.sysml", "MachineViews::vehicleStates"},
+		{"action.sysml", "FlowViews::driveView"},
+		{"sequence.sysml", "SequenceViews::pubSubView"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			rendering := render(t, tc.file, tc.name)
+			for _, form := range rendering.Kind.SupportedForms() {
+				plain, err := rendering.Write(form)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for name, options := range map[string]Options{
+					"zero links":             {},
+					"template without sites": {Links: Links{Template: "https://example.com/{file}"}},
+				} {
+					got, err := rendering.WriteWith(form, options)
+					if err != nil {
+						t.Fatalf("%s, %s: %v", form, name, err)
+					}
+					if got != plain {
+						t.Errorf("%s, %s changed output without source sites", form, name)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestWriteWithRejectsInvalidLinkTemplate(t *testing.T) {
+	rendering := render(t, "tree.sysml", "VehicleViews::vehicleView")
+	_, err := rendering.WriteWith(FormMermaid, Options{Links: Links{Template: "https://example.com/{"}})
+	if err == nil {
+		t.Fatal("WriteWith succeeded with an unclosed link placeholder")
+	}
+	if !strings.Contains(err.Error(), "unclosed") {
+		t.Errorf("error = %v, want an unclosed-placeholder error", err)
+	}
+}
+
+func TestLinkedDiagramGoldens(t *testing.T) {
+	cases := []struct {
+		name, file, view string
+		forms            []Form
+	}{
+		{"interconnection", "interconnection.sysml", "PlantViews::loopView", []Form{FormMermaid, FormDot, FormPlantUML}},
+		{"tree", "tree.sysml", "VehicleViews::vehicleView", []Form{FormMermaid, FormDot, FormPlantUML}},
+		{"state", "state.sysml", "MachineViews::vehicleStates", []Form{FormMermaid, FormDot, FormPlantUML}},
+		{"action", "action.sysml", "FlowViews::driveView", []Form{FormMermaid, FormDot, FormPlantUML}},
+		{"sequence", "sequence.sysml", "SequenceViews::pubSubView", []Form{FormMermaid, FormPlantUML}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			content, err := os.ReadFile(filepath.Join("testdata", tc.file))
+			if err != nil {
+				t.Fatal(err)
+			}
+			renderer, index := loadSources(t, []string{tc.file}, [][]byte{content})
+			rendering, err := renderer.Render(lookup(t, index, tc.view))
+			if err != nil {
+				t.Fatal(err)
+			}
+			lines := map[string]*source.LineIndex{tc.file: source.NewLineIndex(content)}
+			sites := renderer.Sites(FileLocator(renderer.model, func(doc string) *source.LineIndex {
+				return lines[doc]
+			}))
+			options := Options{Links: Links{
+				Template: "https://example.test/src/{file}#L{line}",
+				Sites:    sites,
+			}}
+			for _, form := range tc.forms {
+				got, err := rendering.WriteWith(form, options)
+				if err != nil {
+					t.Fatalf("write %s: %v", form, err)
+				}
+				path := filepath.Join("testdata", fmt.Sprintf("links-%s-%s.golden", tc.name, form))
+				checkGolden(t, path, got)
+				if form == FormMermaid {
+					assertMermaidClickTargetsDeclared(t, got)
+				}
+			}
+		})
+	}
+}
+
+func TestMermaidFlowchartDoesNotLinkUsedPortSubgraph(t *testing.T) {
+	renderer, index := loadFixtures(t, "action.sysml")
+	rendering, err := renderer.Render(lookup(t, index, "FlowViews::driveView"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	used := rendering.usedPorts(rendering.portView(PortsMinimal))
+	var target *Node
+	var find func(*Node)
+	find = func(node *Node) {
+		if target != nil {
+			return
+		}
+		if len(node.Children) == 0 && rendering.hasUsedPorts(node, used) {
+			target = node
+			return
+		}
+		for _, child := range node.Children {
+			find(child)
+		}
+	}
+	for _, root := range rendering.Roots {
+		find(root)
+	}
+	if target == nil {
+		t.Fatal("action fixture has no childless node with a used port")
+	}
+
+	lineIndex := fixtureText(t, "action.sysml").Lines()
+	links := Links{
+		Template: "https://example.test/src/{file}#L{line}",
+		Sites: renderer.Sites(FileLocator(renderer.model, func(doc string) *source.LineIndex {
+			if doc != "action.sysml" {
+				return nil
+			}
+			return lineIndex
+		})),
+	}
+	if _, ok := links.URL(target.Origin); !ok {
+		t.Fatalf("used-port action %q has no source URL", target.ID)
+	}
+	input, err := rendering.WriteWith(FormMermaid, Options{Links: links})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want := "subgraph " + target.ID + " ["; !strings.Contains(input, want) {
+		t.Errorf("used-port action %q is not drawn as a subgraph:\n%s", target.ID, input)
+	}
+	if unexpected := "click " + target.ID + " "; strings.Contains(input, unexpected) {
+		t.Errorf("Mermaid flowchart linked subgraph ID %q:\n%s", target.ID, input)
+	}
+}
+
+func TestMermaidStateLinksSkipImplicitPseudostates(t *testing.T) {
+	origin := Origin{Doc: "machine.sysml", Span: source.Span{Offset: 1, Len: 1}}
+	start := &Node{ID: "n1", Kind: startKind, Origin: origin}
+	active := &Node{ID: "n2", Kind: "state", Name: "active", Origin: origin}
+	final := &Node{ID: "n3", Kind: "final", Origin: origin}
+	rendering := &Rendering{
+		Kind: KindState,
+		Roots: []*Node{{
+			ID: "n0", Kind: "state", Name: "machine", Origin: origin,
+			Children: []*Node{start, active, final},
+		}},
+		Edges: []Edge{
+			{From: start.ID, To: active.ID, Kind: EdgeTransition},
+			{From: active.ID, To: final.ID, Kind: EdgeTransition},
+		},
+	}
+	links := Links{
+		Template: "https://example.test/src/{file}#L{line}",
+		Sites: func(got Origin) (Site, bool) {
+			return Site{File: got.Doc, Line: 1, Col: 1}, got.Located()
+		},
+	}
+	got, err := rendering.WriteWith(FormMermaid, Options{Links: links})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(got, "[*] --> "+active.ID) || !strings.Contains(got, active.ID+" --> [*]") {
+		t.Errorf("test start and final were not converted to [*]:\n%s", got)
+	}
+	for _, id := range []string{start.ID, final.ID} {
+		if unexpected := "click " + id + " "; strings.Contains(got, unexpected) {
+			t.Errorf("Mermaid state linked undeclared pseudostate %q:\n%s", id, got)
+		}
+	}
+	if expected := "click " + active.ID + " "; !strings.Contains(got, expected) {
+		t.Errorf("Mermaid state omitted the declared state's link %q:\n%s", active.ID, got)
+	}
+	assertMermaidClickTargetsDeclared(t, got)
+}
+
+func assertMermaidClickTargetsDeclared(t *testing.T, diagram string) {
+	t.Helper()
+	flowchartNode := regexp.MustCompile(`^([A-Za-z_][A-Za-z0-9_]*)[[:space:]]*(\[|\(|\{|@)`)
+	stateNode := regexp.MustCompile(`^state[[:space:]]+".*"[[:space:]]+as[[:space:]]+([A-Za-z_][A-Za-z0-9_]*)`)
+	declared := map[string]bool{}
+	for _, line := range strings.Split(diagram, "\n") {
+		line = strings.TrimSpace(line)
+		if match := stateNode.FindStringSubmatch(line); len(match) > 1 {
+			declared[match[1]] = true
+		} else if match := flowchartNode.FindStringSubmatch(line); len(match) > 1 {
+			declared[match[1]] = true
+		}
+	}
+	for _, line := range strings.Split(diagram, "\n") {
+		fields := strings.Fields(strings.TrimSpace(line))
+		if len(fields) >= 2 && fields[0] == "click" && !declared[fields[1]] {
+			t.Errorf("Mermaid click targets undeclared node %q in:\n%s", fields[1], diagram)
+		}
+	}
+}
+
+func TestPlantUMLLinksPrecedeColorsAndExcludePorts(t *testing.T) {
+	renderer, index := loadFixtures(t, "interconnection-ports.sysml")
+	rendering, err := renderer.Render(lookup(t, index, "ToasterViews::toasterView"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{
+		Palette: PaletteOkabeIto,
+		Links: Links{
+			Template: "https://example.test/{file}#L{line}",
+			Sites: renderer.Sites(func(origin Origin) (string, source.Pos, bool) {
+				return origin.Doc, source.Pos{Line: 4, Col: 2}, origin.Located()
+			}),
+		},
+	}
+	got, err := rendering.WriteWith(FormPlantUML, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	foundLink, foundColor := false, false
+	for _, line := range strings.Split(got, "\n") {
+		if strings.HasPrefix(strings.TrimSpace(line), "port ") && strings.Contains(line, "[[") {
+			t.Errorf("PlantUML port carries a link: %s", line)
+		}
+		link := strings.Index(line, " [[")
+		trimmed := strings.TrimSpace(line)
+		if (strings.HasPrefix(trimmed, "class ") || strings.HasPrefix(trimmed, "rectangle ")) && link >= 0 {
+			foundLink = true
+			stereotype := strings.Index(line, ">>")
+			if stereotype < 0 || stereotype > link {
+				t.Errorf("link is not after stereotypes: %s", line)
+			}
+			if color := strings.Index(line, " #"); color >= 0 {
+				foundColor = true
+				if link > color {
+					t.Errorf("link follows color: %s", line)
+				}
+			}
+		}
+	}
+	if !foundLink || !foundColor {
+		t.Errorf("PlantUML output did not exercise a linked colored node:\n%s", got)
+	}
+}
+
+func TestPlantUMLPseudostateLinksAreOmittedWhenSVGDropsThem(t *testing.T) {
+	origin := Origin{Doc: "model.sysml", Span: source.Span{Offset: 1, Len: 1}}
+	writer := plantumlWriter{links: Links{
+		Template: "https://example.test/{file}",
+		Sites: func(Origin) (Site, bool) {
+			return Site{File: "model.sysml", Line: 1, Col: 1}, true
+		},
+	}}
+	for _, tc := range []struct {
+		kind, stereotype string
+	}{
+		{"initial", "start"},
+		{"fork", "fork"},
+		{"join", "join"},
+		{"final", "end"},
+		{"decision", "choice"},
+		{"choice", "choice"},
+		{"merge", "choice"},
+		{"junction", "choice"},
+		{"shallow history", "history"},
+		{"deep history", "history*"},
+	} {
+		t.Run(tc.kind, func(t *testing.T) {
+			got := writer.decoration(&Node{Kind: tc.kind, Origin: origin})
+			if want := " <<" + tc.stereotype + ">>"; got != want {
+				t.Errorf("decoration = %q, want unlinked pseudostate %q", got, want)
+			}
+		})
+	}
+}
+
+func TestLinkWritersDoNotLinkZeroOrigins(t *testing.T) {
+	renderer, index := loadFixtures(t, "interconnection.sysml")
+	rendering, err := renderer.Render(lookup(t, index, "PlantViews::loopView"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	zero := Origin{}
+	links := Links{
+		Template: "https://example.test/{file}",
+		Sites: func(Origin) (Site, bool) {
+			return Site{File: "model.sysml"}, true
+		},
+	}
+	if url, ok := links.URL(zero); ok || url != "" {
+		t.Fatalf("zero origin URL = %q, %t", url, ok)
+	}
+	copy := *rendering
+	copy.Roots = []*Node{{ID: "n0", Kind: "part", Name: "synthetic", Origin: zero}}
+	copy.Edges = []Edge{{From: "n0", To: "n0", Kind: EdgeConnection, Origin: zero}}
+	for _, form := range []Form{FormMermaid, FormDot, FormPlantUML} {
+		got, err := copy.WriteWith(form, Options{Links: links})
+		if err != nil {
+			t.Errorf("%s: %v", form, err)
+			continue
+		}
+		if strings.Contains(got, "https://example.test/") {
+			t.Errorf("%s linked a zero origin:\n%s", form, got)
+		}
+	}
+}
+
+func TestLinkedFormsRenderAsSVG(t *testing.T) {
+	renderer, index := loadFixtures(t, "interconnection.sysml")
+	rendering, err := renderer.Render(lookup(t, index, "PlantViews::loopView"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	links := Links{
+		Template: "https://example.test/src/{file}#L{line}",
+		Sites: renderer.Sites(func(origin Origin) (string, source.Pos, bool) {
+			return origin.Doc, source.Pos{Line: 2, Col: 1}, origin.Located()
+		}),
+	}
+	for _, form := range []Form{FormDot, FormPlantUML, FormMermaid} {
+		t.Run(string(form), func(t *testing.T) {
+			input, err := rendering.WriteWith(form, Options{Links: links})
+			if err != nil {
+				t.Fatal(err)
+			}
+			svg := renderLinkedSVG(t, form, input)
+			svgText := string(svg)
+			if !strings.Contains(svgText, "xlink:href=") || strings.Contains(svgText, "Syntax Error") {
+				t.Errorf("%s SVG has no linked anchor:\nsource:\n%s\nsvg:\n%s", form, input, svg)
+			}
+		})
+	}
+}
+
+func TestDOTCompositeLinkRendersAsVisibleClusterAnchor(t *testing.T) {
+	renderer, index := loadFixtures(t, "interconnection.sysml")
+	rendering, err := renderer.Render(lookup(t, index, "PlantViews::loopView"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cluster := rendering.Roots[0]
+	if len(cluster.Children) == 0 {
+		t.Fatal("fixture root is not a composite cluster")
+	}
+	lineIndex := fixtureText(t, "interconnection.sysml").Lines()
+	links := Links{
+		Template: "https://example.test/src/{file}#L{line}",
+		Sites: renderer.Sites(FileLocator(renderer.model, func(doc string) *source.LineIndex {
+			if doc != "interconnection.sysml" {
+				return nil
+			}
+			return lineIndex
+		})),
+	}
+	clusterURL, ok := links.URL(cluster.Origin)
+	if !ok {
+		t.Fatal("composite cluster has no source URL")
+	}
+	input, err := rendering.WriteWith(FormDot, Options{Links: links})
+	if err != nil {
+		t.Fatal(err)
+	}
+	svg := renderLinkedSVG(t, FormDot, input)
+	if !svgAnchorContainsElement(svg, clusterURL, "polygon") {
+		t.Errorf("composite URL %q is not an SVG anchor around visible cluster content:\n%s", clusterURL, svg)
+	}
+}
+
+func TestPlantUMLLinkedArrowFormsRenderAsSVG(t *testing.T) {
+	for _, tc := range []struct {
+		file, name string
+	}{
+		{"interconnection-ports.sysml", "ToasterViews::toasterView"},
+		{"state.sysml", "MachineViews::vehicleStates"},
+		{"action.sysml", "FlowViews::driveView"},
+		{"sequence.sysml", "SequenceViews::pubSubView"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			renderer, index := loadFixtures(t, tc.file)
+			rendering, err := renderer.Render(lookup(t, index, tc.name))
+			if err != nil {
+				t.Fatal(err)
+			}
+			lineIndex := fixtureText(t, tc.file).Lines()
+			links := Links{
+				Template: "https://example.test/src/{file}#L{line}",
+				Sites: renderer.Sites(FileLocator(renderer.model, func(doc string) *source.LineIndex {
+					if doc != tc.file {
+						return nil
+					}
+					return lineIndex
+				})),
+			}
+			input, err := rendering.WriteWith(FormPlantUML, Options{Links: links})
+			if err != nil {
+				t.Fatal(err)
+			}
+			svg := renderLinkedSVG(t, FormPlantUML, input)
+			svgText := string(svg)
+			if !strings.Contains(svgText, "xlink:href=") || strings.Contains(svgText, "Syntax Error") {
+				t.Errorf("PlantUML SVG has no linked anchor:\nsource:\n%s\nsvg:\n%s", input, svg)
+			}
+			if tc.file == "state.sysml" || tc.file == "action.sysml" {
+				for _, url := range plantUMLLinkURLs(input, false) {
+					if !svgAnchorHasHref(svg, url) {
+						t.Errorf("PlantUML SVG has no anchor for emitted link %q", url)
+					}
+				}
+				for _, url := range plantUMLLinkURLs(input, true) {
+					if !svgAnchorHasHref(svg, url) {
+						t.Errorf("PlantUML SVG swallowed a child's own link %q inside a linked composite", url)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestMermaidSequenceLinkFragmentsAreDroppedInSVG(t *testing.T) {
+	renderer, index := loadFixtures(t, "sequence.sysml")
+	rendering, err := renderer.Render(lookup(t, index, "SequenceViews::pubSubView"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	lineIndex := fixtureText(t, "sequence.sysml").Lines()
+	links := Links{
+		Template: "https://example.test/src/{file}#L{line}",
+		Sites: renderer.Sites(FileLocator(renderer.model, func(doc string) *source.LineIndex {
+			if doc != "sequence.sysml" {
+				return nil
+			}
+			return lineIndex
+		})),
+	}
+	sourceURL, ok := links.URL(rendering.Roots[0].Origin)
+	if !ok || !strings.Contains(sourceURL, "#L") {
+		t.Fatalf("sequence participant source URL = %q, %t; want URL with a line fragment", sourceURL, ok)
+	}
+	input, err := rendering.WriteWith(FormMermaid, Options{Links: links})
+	if err != nil {
+		t.Fatal(err)
+	}
+	svg := renderLinkedSVG(t, FormMermaid, input)
+	expected := strings.SplitN(sourceURL, "#", 2)[0]
+	hrefs := svgAnchorHrefs(svg)
+	found := false
+	for _, href := range hrefs {
+		if href == expected {
+			found = true
+		}
+		if strings.HasPrefix(href, expected+"#L") {
+			t.Errorf("Mermaid sequence SVG retained the fragment unexpectedly: %q", href)
+		}
+	}
+	if !found {
+		t.Errorf("Mermaid sequence SVG does not contain fragmentless href %q; got %q", expected, hrefs)
+	}
+}
+
+func plantUMLLinkURLs(input string, nodesOnly bool) []string {
+	pattern := regexp.MustCompile(`\[\[([^\]]+)\]\]`)
+	var urls []string
+	for _, line := range strings.Split(input, "\n") {
+		if nodesOnly && !strings.HasPrefix(strings.TrimSpace(line), "state ") {
+			continue
+		}
+		for _, match := range pattern.FindAllStringSubmatch(line, -1) {
+			urls = append(urls, match[1])
+		}
+	}
+	return urls
+}
+
+func svgAnchorHrefs(svg []byte) []string {
+	decoder := xml.NewDecoder(bytes.NewReader(svg))
+	var hrefs []string
+	for {
+		token, err := decoder.Token()
+		if err != nil {
+			return hrefs
+		}
+		element, ok := token.(xml.StartElement)
+		if !ok || element.Name.Local != "a" {
+			continue
+		}
+		for _, attr := range element.Attr {
+			if attr.Name.Local == "href" {
+				hrefs = append(hrefs, attr.Value)
+			}
+		}
+	}
+}
+
+func svgAnchorHasHref(svg []byte, href string) bool {
+	for _, got := range svgAnchorHrefs(svg) {
+		if got == href {
+			return true
+		}
+	}
+	return false
+}
+
+func svgAnchorContainsElement(svg []byte, href, child string) bool {
+	decoder := xml.NewDecoder(bytes.NewReader(svg))
+	inTargetAnchor := false
+	anchorDepth := 0
+	for {
+		token, err := decoder.Token()
+		if err != nil {
+			return false
+		}
+		switch element := token.(type) {
+		case xml.StartElement:
+			if inTargetAnchor {
+				if element.Name.Local == child {
+					return true
+				}
+				if element.Name.Local == "a" {
+					anchorDepth++
+				}
+				continue
+			}
+			if element.Name.Local != "a" {
+				continue
+			}
+			for _, attr := range element.Attr {
+				if attr.Name.Local == "href" && attr.Value == href {
+					inTargetAnchor = true
+					anchorDepth = 1
+					break
+				}
+			}
+		case xml.EndElement:
+			if inTargetAnchor && element.Name.Local == "a" {
+				anchorDepth--
+				if anchorDepth == 0 {
+					inTargetAnchor = false
+				}
+			}
+		}
+	}
+}
+
+func renderLinkedSVG(t *testing.T, form Form, input string) []byte {
+	t.Helper()
+	switch form {
+	case FormDot:
+		binary, err := exec.LookPath("dot")
+		if err != nil {
+			t.Skip("Graphviz dot is not installed")
+		}
+		command := exec.Command(binary, "-Tsvg")
+		command.Stdin = strings.NewReader(input)
+		output, err := command.CombinedOutput()
+		if err != nil {
+			t.Fatalf("dot -Tsvg: %v\n%s", err, output)
+		}
+		return output
+	case FormPlantUML:
+		jar := os.Getenv("OPENSYSML_PLANTUML_JAR")
+		if jar == "" {
+			jar = filepath.Join("..", "..", "..", "build", "doc-pdf", "plantuml", "plantuml-1.2026.8.jar")
+		}
+		if _, err := os.Stat(jar); err != nil {
+			t.Skip("PlantUML jar is not installed")
+		}
+		java, err := exec.LookPath("java")
+		if err != nil {
+			t.Skip("java is not installed")
+		}
+		command := exec.Command(java, "-Djava.awt.headless=true", "-jar", jar, "-tsvg", "-pipe")
+		command.Stdin = strings.NewReader(input)
+		output, err := command.CombinedOutput()
+		if err != nil {
+			t.Fatalf("PlantUML SVG: %v\n%s", err, output)
+		}
+		return output
+	case FormMermaid:
+		binary := os.Getenv("OPENSYSML_MMDC")
+		if binary == "" {
+			var err error
+			binary, err = exec.LookPath("mmdc")
+			if err != nil {
+				t.Skip("Mermaid CLI is not installed")
+			}
+		}
+		dir := t.TempDir()
+		inputPath, outputPath := filepath.Join(dir, "diagram.mmd"), filepath.Join(dir, "diagram.svg")
+		if err := os.WriteFile(inputPath, []byte(input), 0o600); err != nil {
+			t.Fatal(err)
+		}
+		args := []string{"-i", inputPath, "-o", outputPath}
+		if puppeteer := os.Getenv("OPENSYSML_MMDC_PUPPETEER"); puppeteer != "" {
+			args = append(args, "-p", puppeteer)
+		}
+		command := exec.Command(binary, args...)
+		if output, err := command.CombinedOutput(); err != nil {
+			t.Fatalf("mmdc: %v\n%s", err, output)
+		}
+		svg, err := os.ReadFile(outputPath)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return svg
+	default:
+		t.Fatalf("unsupported SVG form %s", form)
+		return nil
+	}
+}
diff --git a/internal/ir/view/mermaid.go b/internal/ir/view/mermaid.go
index 67133a8b41..5430f7f73b 100644
--- a/internal/ir/view/mermaid.go
+++ b/internal/ir/view/mermaid.go
@@ -568,9 +568,8 @@ func clusterTitleExtraLines(node *Node, ports portView, labels labeller) int {
 	return extra
 }
 
-// flowchartCluster reports whether node is written as a subgraph: one holding
-// nodes, or an interconnection's part with ports the display draws, since a
-// flowchart has no port element and a pin is a node inside its part.
+// flowchartCluster reports whether a node holds flowchart nodes, or is an
+// interconnection part with displayed ports.
 func flowchartCluster(node *Node, ports portView) bool {
 	return len(node.Children) > 0 || (ports.interconnection && len(ports.of(node)) > 0)
 }
@@ -673,6 +672,27 @@ func (r *Rendering) writeFlowchart(b *strings.Builder, direction Direction, labe
 	flowchart.writeFlowchartNoteEdges(w, noteOwners, used)
 	r.writeMermaidStyles(b, fills, options, false)
 	w.writeClasses(flowchart.Notes, options)
+	r.writeFlowchartLinks(b, options, used)
+}
+
+func (r *Rendering) writeFlowchartLinks(b *strings.Builder, options Options, used map[string]map[string]bool) {
+	if !options.Links.Enabled() {
+		return
+	}
+	var walk func(*Node)
+	walk = func(node *Node) {
+		if r.Kind == KindTree || !r.flowchartSubgraph(node, used) {
+			if url, ok := options.Links.URL(node.Origin); ok {
+				fmt.Fprintf(b, "  click %s href \"%s\"\n", node.ID, url)
+			}
+		}
+		for _, child := range node.Children {
+			walk(child)
+		}
+	}
+	for _, root := range r.Roots {
+		walk(root)
+	}
 }
 
 // writeFlowchartNoteEdges draws the dotted edge from each note group to the
@@ -1084,7 +1104,7 @@ func mermaidFontFamily(font string) bool {
 // writeFlowchartNode writes a subgraph for a node with children or used ports.
 func (r *Rendering) writeFlowchartNode(w *mermaidFlowWriter, node *Node, depth int, ctx flowchartContext) {
 	indent := strings.Repeat("  ", depth)
-	if !flowchartCluster(node, ctx.ports) && !r.hasUsedPorts(node, ctx.used) {
+	if !r.flowchartSubgraph(node, ctx.used) {
 		fmt.Fprintf(w.b, "%s%s%s\n", indent, node.ID, mermaidNodeShape(node, ctx.labels, ctx.options))
 		return
 	}
@@ -1470,6 +1490,27 @@ func (r *Rendering) writeStateDiagram(b *strings.Builder, direction Direction, l
 		writeStateEdge(b, edge.From, edge.To, edge.Label, 1)
 	}
 	r.writeMermaidStyles(b, fills, options, true)
+	r.writeStateLinks(b, options, chart)
+}
+
+func (r *Rendering) writeStateLinks(b *strings.Builder, options Options, chart *stateChart) {
+	if !options.Links.Enabled() {
+		return
+	}
+	var walk func(*Node)
+	walk = func(node *Node) {
+		if len(node.Children) == 0 && node.Kind != startKind && !chart.convertedFinals[node.ID] {
+			if url, ok := options.Links.URL(node.Origin); ok {
+				fmt.Fprintf(b, "  click %s href \"%s\"\n", node.ID, url)
+			}
+		}
+		for _, child := range node.Children {
+			walk(child)
+		}
+	}
+	for _, root := range r.Roots {
+		walk(root)
+	}
 }
 
 // indexStateChart gathers what writeStateDiagram writes the transitions from.
@@ -1552,7 +1593,6 @@ func writeStateEdge(b *strings.Builder, from, to, label string, depth int) {
 // diagram: one participant per lifeline, declared before the messages, then the
 // messages in the order the rendering settled on.
 func (r *Rendering) writeSequenceDiagram(b *strings.Builder, labels labeller, options Options) {
-	_ = options
 	b.WriteString("sequenceDiagram\n")
 	if r.blank() {
 		// A sequence diagram carries no free text, so the reason is a
@@ -1562,6 +1602,9 @@ func (r *Rendering) writeSequenceDiagram(b *strings.Builder, labels labeller, op
 	}
 	for _, node := range r.Roots {
 		fmt.Fprintf(b, "  participant %s as %s\n", node.ID, labels.mermaid(node))
+		if url, ok := options.Links.URL(node.Origin); ok {
+			fmt.Fprintf(b, "  link %s: Source @ %s\n", node.ID, url)
+		}
 	}
 	r.writeSequenceNotes(b)
 	writtenNotes := map[int]bool{}
diff --git a/internal/ir/view/plantuml.go b/internal/ir/view/plantuml.go
index 020137267b..353ec00cba 100644
--- a/internal/ir/view/plantuml.go
+++ b/internal/ir/view/plantuml.go
@@ -38,7 +38,7 @@ func (r *Rendering) PlantUMLWith(options Options) (string, error) {
 	}
 	r = r.settleUnplaced(options.Unplaced, FormPlantUML)
 	w := &plantumlWriter{borders: r.Kind.paletteBorders(), fills: familyFills{palette: options.Palette, tree: r.Kind == KindTree},
-		labels: labelsOf(r.Roots, false, nil), ports: r.portView(options.Ports)}
+		labels: labelsOf(r.Roots, false, nil), ports: r.portView(options.Ports), links: options.Links}
 	for _, root := range r.Roots {
 		w.fills.collect(root)
 	}
@@ -103,6 +103,7 @@ type plantumlWriter struct {
 	fills   familyFills // the palette fills, by keyword family
 	labels  labeller    // the node labels, headed relative to the roots' namespace
 	ports   portView    // the ports drawn of each node, and how they are named
+	links   Links
 }
 
 // countGeometry counts the nodes a Geometry positions and the edges with a route.
@@ -237,7 +238,7 @@ func (w *plantumlWriter) writeRectangleDiagram(r *Rendering) {
 		w.writeRectangleNode(root, 0)
 	}
 	for _, edge := range r.Edges {
-		w.writeArrow("", portOr(edge.FromPort, edge.From), portOr(edge.ToPort, edge.To), plantumlArrow(edge.Kind), edge.Label)
+		w.writeArrowEdge(edge, portOr(edge.FromPort, edge.From), portOr(edge.ToPort, edge.To), false)
 	}
 }
 
@@ -318,7 +319,7 @@ func (w *plantumlWriter) writeStateNode(node *Node, depth int, starts map[string
 	}
 	for _, child := range node.Children {
 		for _, edge := range starts[child.ID] {
-			w.writeArrow(indent+"  ", "[*]", edge.To, plantumlArrow(edge.Kind), edge.Label)
+			w.writeArrow(indent+"  ", "[*]", edge.To, plantumlArrow(edge.Kind), edge.Label, Origin{}, false)
 		}
 	}
 	fmt.Fprintf(&w.b, "%s}\n", indent)
@@ -337,22 +338,42 @@ func (w *plantumlWriter) writeSequenceDiagram(r *Rendering) {
 		fmt.Fprintf(b, "participant %s as %s%s\n", plantumlQuote(w.plantumlLabel(node)), node.ID, w.decoration(node))
 	}
 	for _, edge := range r.Edges {
-		w.writeArrow("", edge.From, edge.To, "->", edge.Label)
+		w.writeArrowEdge(edge, edge.From, edge.To, true)
 	}
 }
 
 // writeEdge writes one edge as its kind's arrow, with its label when it carries one.
 func (w *plantumlWriter) writeEdge(edge Edge) {
-	w.writeArrow("", edge.From, edge.To, plantumlArrow(edge.Kind), edge.Label)
+	w.writeArrowEdge(edge, edge.From, edge.To, false)
 }
 
 // writeArrow writes one arrow statement between two aliases.
-func (w *plantumlWriter) writeArrow(indent, from, to, arrow, label string) {
+func (w *plantumlWriter) writeArrow(indent, from, to, arrow, label string, origin Origin, sequence bool) {
+	link := ""
+	if url, ok := w.links.URL(origin); ok {
+		link = " [[" + url + "]]"
+	}
 	if label == "" {
-		fmt.Fprintf(&w.b, "%s%s %s %s\n", indent, from, arrow, to)
+		if link != "" && !sequence {
+			fmt.Fprintf(&w.b, "%s%s %s %s :%s\n", indent, from, arrow, to, link)
+			return
+		}
+		fmt.Fprintf(&w.b, "%s%s %s %s%s\n", indent, from, arrow, to, link)
+		return
+	}
+	if sequence && link != "" {
+		fmt.Fprintf(&w.b, "%s%s %s %s :%s %s\n", indent, from, arrow, to, link, plantumlText(label))
 		return
 	}
-	fmt.Fprintf(&w.b, "%s%s %s %s : %s\n", indent, from, arrow, to, plantumlText(label))
+	fmt.Fprintf(&w.b, "%s%s %s %s : %s%s\n", indent, from, arrow, to, plantumlText(label), link)
+}
+
+func (w *plantumlWriter) writeArrowEdge(edge Edge, from, to string, sequence bool) {
+	arrow := plantumlArrow(edge.Kind)
+	if sequence {
+		arrow = "->"
+	}
+	w.writeArrow("", from, to, arrow, edge.Label, edge.Origin, sequence)
 }
 
 // plantumlStyleColor is a Style's colours as PlantUML's inline colour,
@@ -391,6 +412,11 @@ func (w *plantumlWriter) decoration(node *Node) string {
 	if pseudostate := plantumlPseudostates[node.Kind]; pseudostate != "" {
 		// PlantUML draws a pseudostate only when its stereotype stands alone.
 		fmt.Fprintf(&out, " <<%s>>", pseudostate)
+		if _, unlinked := plantumlUnlinkedPseudostates[pseudostate]; !unlinked {
+			if url, ok := w.links.URL(node.Origin); ok {
+				fmt.Fprintf(&out, " [[%s]]", url)
+			}
+		}
 		return out.String()
 	}
 	if node.Kind != "" {
@@ -399,6 +425,9 @@ func (w *plantumlWriter) decoration(node *Node) string {
 	if shape := plantumlShapeStereotype(node); shape != "" && shape != node.Kind {
 		fmt.Fprintf(&out, " <<%s>>", shape)
 	}
+	if url, ok := w.links.URL(node.Origin); ok {
+		fmt.Fprintf(&out, " [[%s]]", url)
+	}
 	switch {
 	case w.fills.filled(node):
 		out.WriteString(" " + w.fills.fill(node))
@@ -424,6 +453,11 @@ var plantumlPseudostates = map[string]string{
 	"shallow history": "history", "deep history": "history*",
 }
 
+// PlantUML does not retain links on these pseudostate stereotypes in SVG.
+var plantumlUnlinkedPseudostates = map[string]struct{}{
+	"start": {}, "fork": {}, "join": {}, "end": {}, "choice": {}, "history": {}, "history*": {},
+}
+
 // plantumlShapeStereotype is the stereotype the style block shapes a node by:
 // `package` for a package's heavier border, `usage` for a usage's rounded
 // corners; a definition or an orthogonal region keeps the element rules.
diff --git a/internal/ir/view/testdata/links-action-dot.golden b/internal/ir/view/testdata/links-action-dot.golden
new file mode 100644
index 0000000000..850f72b627
--- /dev/null
+++ b/internal/ir/view/testdata/links-action-dot.golden
@@ -0,0 +1,49 @@
+// view: FlowViews::driveView
+// kind: action
+// stated: render asInterconnectionDiagram, view def ActionFlowView
+// layout: dot
+digraph "FlowViews::driveView" {
+  graph [fontname="Helvetica", compound=true];
+  node [shape=box, style=filled, fillcolor=white, color="#181818", fontname="Helvetica", fontsize=14, penwidth=0.5];
+  edge [color="#181818", fontname="Helvetica", fontsize=13, penwidth=1];
+  subgraph "cluster_n0" {
+    label=<<font point-size="10"><i>«action def»</i></font><br/><b>Drive</b>>;
+    color=black;
+    penwidth=0.5;
+    URL="https://example.test/src/action.sysml#L11";
+    tooltip="Flows::Drive";
+    "n0" [shape=point, style=invis, width=0, height=0, label=""];
+    "n1" [shape=circle, fillcolor=black, label="", width=0.2, URL="https://example.test/src/action.sysml#L14", tooltip="Flows::Drive::start"];
+    "n2" [style="rounded,filled", label=<<table border="0" cellborder="0" cellspacing="0" cellpadding="2"><tr><td port="n2.0" border="1" fixedsize="true" width="10" height="10"></td><td align="left"><font point-size="8">fuel</font></td></tr><tr><td colspan="2"><font point-size="10"><i>«action»</i></font><br/><b>provide : Provide</b></td></tr><tr><td port="n2.1" border="1" fixedsize="true" width="10" height="10"></td><td align="left"><font point-size="8">torque</font></td></tr></table>>, URL="https://example.test/src/action.sysml#L16", tooltip="Flows::Drive::provide"];
+    subgraph "cluster_n3" {
+      label=<<font point-size="10"><i>«action»</i></font><br/><b>monitor</b><br/>own flow>;
+      color=black;
+      penwidth=0.5;
+      URL="https://example.test/src/action.sysml#L20";
+      tooltip="Flows::Drive::monitor";
+      "n3" [shape=point, style=invis, width=0, height=0, label=""];
+      "n3.0" [shape=box, label="", xlabel="reading", fontsize=8, width=0.16666666666666666, height=0.16666666666666666, fixedsize=true];
+      "n4" [shape=circle, fillcolor=black, label="", width=0.2, URL="https://example.test/src/action.sysml#L22", tooltip="Flows::Drive::monitor::begin"];
+      "n5" [style="rounded,filled", label=<<font point-size="10"><i>«action»</i></font><br/><b>record</b>>, URL="https://example.test/src/action.sysml#L23", tooltip="Flows::Drive::monitor::record"];
+    }
+    "n6" [style="rounded,filled", label=<<font point-size="10"><i>«action»</i></font><br/><b>tally</b>>, URL="https://example.test/src/action.sysml#L29", tooltip="Flows::Drive::tally"];
+    "n7" [label=<<font point-size="10"><i>«fork»</i></font><br/><b>split</b>>, URL="https://example.test/src/action.sysml#L33", tooltip="Flows::Drive::split"];
+    "n8" [label=<<font point-size="10"><i>«join»</i></font><br/><b>sync</b>>, URL="https://example.test/src/action.sysml#L34", tooltip="Flows::Drive::sync"];
+    "n9" [shape=doublecircle, fillcolor=black, label="", width=0.2, URL="https://example.test/src/action.sysml#L35", tooltip="action.sysml:35:3"];
+    "n10" [style="rounded,filled", label=<<font point-size="10"><i>«action»</i></font><br/><b>park</b>>, URL="https://example.test/src/action.sysml#L36", tooltip="Flows::Drive::park"];
+    "n11" [label=<<font point-size="10"><i>«decision»</i></font><br/><b>check</b>>, URL="https://example.test/src/action.sysml#L46", tooltip="Flows::Drive::check"];
+  }
+  "n4" -> "n5" [URL="https://example.test/src/action.sysml#L24", tooltip="action.sysml:24:4"];
+  "n1" -> "n7" [URL="https://example.test/src/action.sysml#L38", tooltip="action.sysml:38:3"];
+  "n2" -> "n8" [URL="https://example.test/src/action.sysml#L41", tooltip="action.sysml:41:3"];
+  "n2":"n2.1" -> "n3.0" [style=dashed, URL="https://example.test/src/action.sysml#L52", tooltip="action.sysml:52:3"];
+  "n3" -> "n8" [URL="https://example.test/src/action.sysml#L42", tooltip="action.sysml:42:3", ltail="cluster_n3"];
+  "n6" -> "n8" [URL="https://example.test/src/action.sysml#L44", tooltip="action.sysml:44:3"];
+  "n7" -> "n2" [URL="https://example.test/src/action.sysml#L39", tooltip="action.sysml:39:3"];
+  "n7" -> "n3" [URL="https://example.test/src/action.sysml#L40", tooltip="action.sysml:40:3", lhead="cluster_n3"];
+  "n7" -> "n6" [URL="https://example.test/src/action.sysml#L43", tooltip="action.sysml:43:3"];
+  "n8" -> "n11" [URL="https://example.test/src/action.sysml#L47", tooltip="action.sysml:47:3"];
+  "n10" -> "n9" [URL="https://example.test/src/action.sysml#L50", tooltip="action.sysml:50:3"];
+  "n11" -> "n9" [label="[speed > 0]", URL="https://example.test/src/action.sysml#L48", tooltip="action.sysml:48:3"];
+  "n11" -> "n10" [URL="https://example.test/src/action.sysml#L49", tooltip="action.sysml:49:3"];
+}
diff --git a/internal/ir/view/testdata/links-action-mermaid.golden b/internal/ir/view/testdata/links-action-mermaid.golden
new file mode 100644
index 0000000000..572034302a
--- /dev/null
+++ b/internal/ir/view/testdata/links-action-mermaid.golden
@@ -0,0 +1,86 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeCSS: ".edgeLabel rect { opacity: 1 !important; } .cluster-label .nodeLabel { text-align: center; }"
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    clusterBkg: "#FFFFFF"
+    clusterBorder: "#181818"
+    edgeLabelBackground: "#FFFFFF"
+  flowchart:
+    subGraphTitleMargin:
+      bottom: 48
+---
+%% FlowViews::driveView — action rendering (render asInterconnectionDiagram, view def ActionFlowView)
+%% not represented: 2 fork/join name(s) (split, sync); Mermaid's fork bar draws no label
+%% not represented: 1 pin(s) not drawn (provide.fuel); a flowchart draws the pins an edge ends at
+flowchart TD
+  subgraph n0 ["`*«action def»*
+**Drive**`"]
+    direction TD
+    n1@{ shape: f-circ, label: "" }
+    subgraph n2 ["`*«action»*
+**provide : Provide**`"]
+      direction TD
+      n2_anchor[" "]
+      n2_p1["torque"]
+    end
+    subgraph n3 ["`*«action»*
+**monitor**
+own flow`"]
+      direction TD
+      n3_anchor[" "]
+      n3_p0["reading"]
+      n4@{ shape: f-circ, label: "" }
+      n5("`*«action»*
+**record**`")
+    end
+    n6("`*«action»*
+**tally**`")
+    n7@{ shape: fork, label: "split" }
+    n8@{ shape: fork, label: "sync" }
+    n9@{ shape: fr-circ, label: "" }
+    n10("`*«action»*
+**park**`")
+    n11{"`*«decision»*
+**check**`"}
+  end
+  n4 --> n5
+  n1 --> n7
+  n2_anchor --> n8
+  n2_p1 -.->|"torque to reading"| n3_p0
+  n3_anchor --> n8
+  n6 --> n8
+  n7 --> n2_anchor
+  n7 --> n3_anchor
+  n7 --> n6
+  n8 --> n11
+  n10 --> n9
+  n11 -->|"[speed #gt; 0]"| n9
+  n11 --> n10
+  classDef control fill:#181818,stroke:#181818
+  class n7,n8 control
+  classDef anchor fill:none,stroke:none
+  class n2_anchor,n3_anchor anchor
+  click n1 href "https://example.test/src/action.sysml#L14"
+  click n4 href "https://example.test/src/action.sysml#L22"
+  click n5 href "https://example.test/src/action.sysml#L23"
+  click n6 href "https://example.test/src/action.sysml#L29"
+  click n7 href "https://example.test/src/action.sysml#L33"
+  click n8 href "https://example.test/src/action.sysml#L34"
+  click n9 href "https://example.test/src/action.sysml#L35"
+  click n10 href "https://example.test/src/action.sysml#L36"
+  click n11 href "https://example.test/src/action.sysml#L46"
diff --git a/internal/ir/view/testdata/links-action-plantuml.golden b/internal/ir/view/testdata/links-action-plantuml.golden
new file mode 100644
index 0000000000..2dbb4c42f0
--- /dev/null
+++ b/internal/ir/view/testdata/links-action-plantuml.golden
@@ -0,0 +1,72 @@
+@startuml
+' FlowViews::driveView — action rendering (render asInterconnectionDiagram, view def ActionFlowView)
+' not represented: 3 pin(s) not drawn (provide.fuel, provide.torque, monitor.reading); PlantUML's state grammar has no pin, so the edges name them
+<style>
+root {
+  BackGroundColor white
+  FontName SansSerif
+  FontSize 14
+  FontColor black
+  LineColor #181818
+  HorizontalAlignment left
+}
+element {
+  BackGroundColor white
+  LineColor #181818
+  LineThickness 0.5
+  RoundCorner 0
+  Shadowing 0.0
+}
+start, end, activityBar {
+  BackGroundColor black
+}
+arrow {
+  LineColor #181818
+  LineThickness 1
+  FontSize 13
+}
+note {
+  BackGroundColor #FEFFDD
+  FontSize 13
+}
+.usage {
+  RoundCorner 20
+}
+.package {
+  LineThickness 1.5
+}
+.region {
+  LineStyle 4
+}
+</style>
+skinparam wrapWidth 300
+hide stereotype
+hide empty description
+state "<size:10>//«action def»//</size>\n**Drive**" as n0 <<action def>> [[https://example.test/src/action.sysml#L11]] {
+  state "**initial**" as n1 <<start>>
+  state "<size:10>//«action»//</size>\n**provide : Provide**" as n2 <<action>> <<usage>> [[https://example.test/src/action.sysml#L16]]
+  state "<size:10>//«action»//</size>\n**monitor**\nown flow" as n3 <<action>> <<usage>> [[https://example.test/src/action.sysml#L20]] {
+    state "**initial**" as n4 <<start>>
+    state "<size:10>//«action»//</size>\n**record**" as n5 <<action>> <<usage>> [[https://example.test/src/action.sysml#L23]]
+  }
+  state "<size:10>//«action»//</size>\n**tally**" as n6 <<action>> <<usage>> [[https://example.test/src/action.sysml#L29]]
+  state "<size:10>//«fork»//</size>\n**split**" as n7 <<fork>>
+  state "<size:10>//«join»//</size>\n**sync**" as n8 <<join>>
+  state "**final**" as n9 <<end>>
+  state "<size:10>//«action»//</size>\n**park**" as n10 <<action>> <<usage>> [[https://example.test/src/action.sysml#L36]]
+  state "<size:10>//«decision»//</size>\n**check**" as n11 <<choice>>
+}
+n4 --> n5 : [[https://example.test/src/action.sysml#L24]]
+n1 --> n7 : [[https://example.test/src/action.sysml#L38]]
+n2 --> n8 : [[https://example.test/src/action.sysml#L41]]
+n2 -[dashed]-> n3 : torque to reading [[https://example.test/src/action.sysml#L52]]
+n3 --> n8 : [[https://example.test/src/action.sysml#L42]]
+n6 --> n8 : [[https://example.test/src/action.sysml#L44]]
+n7 --> n2 : [[https://example.test/src/action.sysml#L39]]
+n7 --> n3 : [[https://example.test/src/action.sysml#L40]]
+n7 --> n6 : [[https://example.test/src/action.sysml#L43]]
+n8 --> n11 : [[https://example.test/src/action.sysml#L47]]
+n10 --> n9 : [[https://example.test/src/action.sysml#L50]]
+n11 --> n9 : [speed <U+003E> 0] [[https://example.test/src/action.sysml#L48]]
+n11 --> n10 : [[https://example.test/src/action.sysml#L49]]
+@enduml
diff --git a/internal/ir/view/testdata/links-interconnection-dot.golden b/internal/ir/view/testdata/links-interconnection-dot.golden
new file mode 100644
index 0000000000..6fca8bcce6
--- /dev/null
+++ b/internal/ir/view/testdata/links-interconnection-dot.golden
@@ -0,0 +1,22 @@
+// view: PlantViews::loopView
+// kind: interconnection
+// stated: render asInterconnectionDiagram
+// layout: dot
+digraph "PlantViews::loopView" {
+  graph [fontname="Helvetica"];
+  node [shape=box, style=filled, fillcolor=white, color="#181818", fontname="Helvetica", fontsize=14, penwidth=0.5];
+  edge [color="#181818", fontname="Helvetica", fontsize=13, penwidth=1];
+  subgraph "cluster_n0" {
+    label=<<font point-size="10"><i>«part def»</i></font><br/><b>Loop</b>>;
+    color=black;
+    penwidth=0.5;
+    URL="https://example.test/src/interconnection.sysml#L16";
+    tooltip="Plant::Loop";
+    "n0" [shape=point, style=invis, width=0, height=0, label=""];
+    "n1" [shape=plain, label=<<table border="0" cellborder="0" cellspacing="0" cellpadding="0"><tr><td colspan="4"><table border="1" cellborder="0" cellspacing="0" cellpadding="6" style="rounded"><tr><td><font point-size="10"><i>«part»</i></font><br/><b>pump : Pump</b></td></tr></table></td></tr><tr><td></td><td port="n1.0" border="1" fixedsize="true" width="10" height="10" bgcolor="white"></td><td align="left"><font point-size="8">outlet</font></td><td></td></tr></table>>, URL="https://example.test/src/interconnection.sysml#L17", tooltip="Plant::Loop::pump"];
+    "n2" [shape=plain, label=<<table border="0" cellborder="0" cellspacing="0" cellpadding="0"><tr><td></td><td port="n2.0" border="1" fixedsize="true" width="10" height="10" bgcolor="white"></td><td align="left"><font point-size="8">inlet</font></td><td></td></tr><tr><td colspan="4"><table border="1" cellborder="0" cellspacing="0" cellpadding="6" style="rounded"><tr><td><font point-size="10"><i>«part»</i></font><br/><b>tank : Tank</b></td></tr></table></td></tr></table>>, URL="https://example.test/src/interconnection.sysml#L18", tooltip="Plant::Loop::tank"];
+    "n3" [style="rounded,filled", label=<<font point-size="10"><i>«part»</i></font><br/><b>sensor : Pump</b>>, URL="https://example.test/src/interconnection.sysml#L22", tooltip="Plant::Loop::sensor"];
+  }
+  "n1":"n1.0" -> "n2":"n2.0" [label="supply", arrowhead=none, penwidth=3, URL="https://example.test/src/interconnection.sysml#L19", tooltip="Plant::Loop::supply"];
+  "n1" -> "n2" [label="of Water", style=dashed, URL="https://example.test/src/interconnection.sysml#L20", tooltip="interconnection.sysml:20:3"];
+}
diff --git a/internal/ir/view/testdata/links-interconnection-mermaid.golden b/internal/ir/view/testdata/links-interconnection-mermaid.golden
new file mode 100644
index 0000000000..b639732a2c
--- /dev/null
+++ b/internal/ir/view/testdata/links-interconnection-mermaid.golden
@@ -0,0 +1,52 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeCSS: ".edgeLabel rect { opacity: 1 !important; } .cluster-label .nodeLabel { text-align: center; }"
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    clusterBkg: "#FFFFFF"
+    clusterBorder: "#181818"
+    edgeLabelBackground: "#FFFFFF"
+  flowchart:
+    subGraphTitleMargin:
+      bottom: 24
+---
+%% PlantViews::loopView — interconnection rendering (render asInterconnectionDiagram)
+flowchart LR
+  subgraph n0 ["`*«part def»*
+**Loop**`"]
+    direction LR
+    subgraph n1 ["`*«part»*
+**pump : Pump**`"]
+      direction LR
+      n1_anchor[" "]
+      n1.0["outlet"]
+    end
+    subgraph n2 ["`*«part»*
+**tank : Tank**`"]
+      direction LR
+      n2_anchor[" "]
+      n2.0["inlet"]
+    end
+    n3("`*«part»*
+**sensor : Pump**`")
+  end
+  n1.0 ===|"supply"| n2.0
+  n1_anchor -.->|"of Water"| n2_anchor
+  classDef anchor fill:none,stroke:none
+  class n1_anchor,n2_anchor anchor
+  linkStyle 0 stroke-width:3px
+  click n3 href "https://example.test/src/interconnection.sysml#L22"
diff --git a/internal/ir/view/testdata/links-interconnection-plantuml.golden b/internal/ir/view/testdata/links-interconnection-plantuml.golden
new file mode 100644
index 0000000000..dd1027968e
--- /dev/null
+++ b/internal/ir/view/testdata/links-interconnection-plantuml.golden
@@ -0,0 +1,54 @@
+@startuml
+' PlantViews::loopView — interconnection rendering (render asInterconnectionDiagram)
+<style>
+root {
+  BackGroundColor white
+  FontName SansSerif
+  FontSize 14
+  FontColor black
+  LineColor #181818
+  HorizontalAlignment left
+}
+element {
+  BackGroundColor white
+  LineColor #181818
+  LineThickness 0.5
+  RoundCorner 0
+  Shadowing 0.0
+}
+start, end, activityBar {
+  BackGroundColor black
+}
+arrow {
+  LineColor #181818
+  LineThickness 1
+  FontSize 13
+}
+note {
+  BackGroundColor #FEFFDD
+  FontSize 13
+}
+.usage {
+  RoundCorner 20
+}
+.package {
+  LineThickness 1.5
+}
+.region {
+  LineStyle 4
+}
+</style>
+skinparam wrapWidth 300
+hide stereotype
+rectangle "<size:10>//«part def»//</size>\n**Loop**" as n0 <<part def>> [[https://example.test/src/interconnection.sysml#L16]] {
+  rectangle "<size:10>//«part»//</size>\n**pump : Pump**" as n1 <<part>> <<usage>> [[https://example.test/src/interconnection.sysml#L17]] {
+    port "outlet" as n1.0
+  }
+  rectangle "<size:10>//«part»//</size>\n**tank : Tank**" as n2 <<part>> <<usage>> [[https://example.test/src/interconnection.sysml#L18]] {
+    port "inlet" as n2.0
+  }
+  rectangle "<size:10>//«part»//</size>\n**sensor : Pump**" as n3 <<part>> <<usage>> [[https://example.test/src/interconnection.sysml#L22]]
+}
+n1.0 -[thickness=3]- n2.0 : supply [[https://example.test/src/interconnection.sysml#L19]]
+n1 -[dashed]-> n2 : of Water [[https://example.test/src/interconnection.sysml#L20]]
+@enduml
diff --git a/internal/ir/view/testdata/links-sequence-mermaid.golden b/internal/ir/view/testdata/links-sequence-mermaid.golden
new file mode 100644
index 0000000000..c60d382250
--- /dev/null
+++ b/internal/ir/view/testdata/links-sequence-mermaid.golden
@@ -0,0 +1,43 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    actorBkg: "#FFFFFF"
+    actorBorder: "#181818"
+    actorTextColor: "#000000"
+    actorLineColor: "#181818"
+    signalColor: "#181818"
+    signalTextColor: "#000000"
+    labelBoxBkgColor: "#FFFFFF"
+    labelBoxBorderColor: "#181818"
+    labelTextColor: "#000000"
+    loopTextColor: "#000000"
+    activationBorderColor: "#181818"
+    activationBkgColor: "#FFFFFF"
+    sequenceNumberColor: "#000000"
+---
+%% SequenceViews::pubSubView — sequence rendering (view def SequenceView)
+sequenceDiagram
+  participant n0 as «part»<br>producer
+  link n0: Source @ https://example.test/src/sequence.sysml#L26
+  participant n1 as «part»<br>server
+  link n1: Source @ https://example.test/src/sequence.sysml#L32
+  participant n2 as «part»<br>consumer
+  link n2: Source @ https://example.test/src/sequence.sysml#L41
+  n2->>n1: subscribe_message
+  n0->>n1: publish_message
+  n1->>n2: deliver_message
diff --git a/internal/ir/view/testdata/links-sequence-plantuml.golden b/internal/ir/view/testdata/links-sequence-plantuml.golden
new file mode 100644
index 0000000000..4eb341ce6a
--- /dev/null
+++ b/internal/ir/view/testdata/links-sequence-plantuml.golden
@@ -0,0 +1,49 @@
+@startuml
+' SequenceViews::pubSubView — sequence rendering (view def SequenceView)
+<style>
+root {
+  BackGroundColor white
+  FontName SansSerif
+  FontSize 14
+  FontColor black
+  LineColor #181818
+  HorizontalAlignment left
+}
+element {
+  BackGroundColor white
+  LineColor #181818
+  LineThickness 0.5
+  RoundCorner 0
+  Shadowing 0.0
+}
+start, end, activityBar {
+  BackGroundColor black
+}
+arrow {
+  LineColor #181818
+  LineThickness 1
+  FontSize 13
+}
+note {
+  BackGroundColor #FEFFDD
+  FontSize 13
+}
+.usage {
+  RoundCorner 20
+}
+.package {
+  LineThickness 1.5
+}
+.region {
+  LineStyle 4
+}
+</style>
+skinparam wrapWidth 300
+hide stereotype
+participant "<size:10>//«part»//</size>\n**producer**" as n0 <<part>> <<usage>> [[https://example.test/src/sequence.sysml#L26]]
+participant "<size:10>//«part»//</size>\n**server**" as n1 <<part>> <<usage>> [[https://example.test/src/sequence.sysml#L32]]
+participant "<size:10>//«part»//</size>\n**consumer**" as n2 <<part>> <<usage>> [[https://example.test/src/sequence.sysml#L41]]
+n2 -> n1 : [[https://example.test/src/sequence.sysml#L38]] subscribe_message
+n0 -> n1 : [[https://example.test/src/sequence.sysml#L30]] publish_message
+n1 -> n2 : [[https://example.test/src/sequence.sysml#L39]] deliver_message
+@enduml
diff --git a/internal/ir/view/testdata/links-state-dot.golden b/internal/ir/view/testdata/links-state-dot.golden
new file mode 100644
index 0000000000..78afde2c5b
--- /dev/null
+++ b/internal/ir/view/testdata/links-state-dot.golden
@@ -0,0 +1,36 @@
+// view: MachineViews::vehicleStates
+// kind: state
+// stated: view def StateTransitionView
+// layout: dot
+digraph "MachineViews::vehicleStates" {
+  graph [fontname="Helvetica", compound=true];
+  node [shape=box, style=filled, fillcolor=white, color="#181818", fontname="Helvetica", fontsize=14, penwidth=0.5];
+  edge [color="#181818", fontname="Helvetica", fontsize=13, penwidth=1];
+  subgraph "cluster_n0" {
+    label=<<font point-size="10"><i>«state def»</i></font><br/><b>VehicleStates</b>>;
+    color=black;
+    penwidth=0.5;
+    URL="https://example.test/src/state.sysml#L8";
+    tooltip="Machines::VehicleStates";
+    "n0" [shape=point, style=invis, width=0, height=0, label=""];
+    "n5" [shape=point, fillcolor=black, label=""];
+    "n1" [style="rounded,filled", label=<<font point-size="10"><i>«state»</i></font><br/><b>off</b><br/>initial>, URL="https://example.test/src/state.sysml#L13", tooltip="Machines::VehicleStates::off"];
+    subgraph "cluster_n2" {
+      label=<<font point-size="10"><i>«state»</i></font><br/><b>operating</b>>;
+      color=black;
+      penwidth=0.5;
+      URL="https://example.test/src/state.sysml#L14";
+      tooltip="Machines::VehicleStates::operating";
+      "n2" [shape=point, style=invis, width=0, height=0, label=""];
+      "n6" [shape=point, fillcolor=black, label=""];
+      "n3" [style="rounded,filled", label=<<font point-size="10"><i>«state»</i></font><br/><b>idle</b><br/>initial>, URL="https://example.test/src/state.sysml#L17", tooltip="Machines::VehicleStates::operating::idle"];
+      "n4" [style="rounded,filled", label=<<font point-size="10"><i>«state»</i></font><br/><b>moving</b>>, URL="https://example.test/src/state.sysml#L18", tooltip="Machines::VehicleStates::operating::moving"];
+    }
+  }
+  "n5" -> "n1" [URL="https://example.test/src/state.sysml#L11", tooltip="state.sysml:11:10"];
+  "n6" -> "n3" [URL="https://example.test/src/state.sysml#L15", tooltip="state.sysml:15:11"];
+  "n1" -> "n2" [URL="https://example.test/src/state.sysml#L29", tooltip="state.sysml:29:3", lhead="cluster_n2"];
+  "n2" -> "n1" [URL="https://example.test/src/state.sysml#L30", tooltip="state.sysml:30:3", ltail="cluster_n2"];
+  "n3" -> "n4" [label="accept Signal [temperature > 0]", URL="https://example.test/src/state.sysml#L20", tooltip="Machines::VehicleStates::operating::idle_to_moving"];
+  "n4" -> "n3" [URL="https://example.test/src/state.sysml#L26", tooltip="state.sysml:26:4"];
+}
diff --git a/internal/ir/view/testdata/links-state-mermaid.golden b/internal/ir/view/testdata/links-state-mermaid.golden
new file mode 100644
index 0000000000..9c073a9aab
--- /dev/null
+++ b/internal/ir/view/testdata/links-state-mermaid.golden
@@ -0,0 +1,48 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    stateBkg: "#FFFFFF"
+    stateBorder: "#181818"
+    stateLabelColor: "#000000"
+    compositeBackground: "#FFFFFF"
+    compositeBorder: "#181818"
+    compositeTitleBackground: "#FFFFFF"
+    compositeTitleBorder: "#181818"
+    transitionColor: "#181818"
+    transitionLabelColor: "#000000"
+    labelBackgroundColor: "#FFFFFF"
+    specialStateColor: "#181818"
+---
+%% MachineViews::vehicleStates — state rendering (view def StateTransitionView)
+stateDiagram-v2
+  state "«state def»<br>VehicleStates" as n0 {
+    state "«state»<br>off<br>initial" as n1
+    state "«state»<br>operating" as n2 {
+      state "«state»<br>idle<br>initial" as n3
+      state "«state»<br>moving" as n4
+      [*] --> n3
+    }
+    [*] --> n1
+  }
+  n1 --> n2
+  n2 --> n1
+  n3 --> n4 : accept Signal [temperature #gt; 0]
+  n4 --> n3
+  click n1 href "https://example.test/src/state.sysml#L13"
+  click n3 href "https://example.test/src/state.sysml#L17"
+  click n4 href "https://example.test/src/state.sysml#L18"
diff --git a/internal/ir/view/testdata/links-state-plantuml.golden b/internal/ir/view/testdata/links-state-plantuml.golden
new file mode 100644
index 0000000000..474a58a465
--- /dev/null
+++ b/internal/ir/view/testdata/links-state-plantuml.golden
@@ -0,0 +1,57 @@
+@startuml
+' MachineViews::vehicleStates — state rendering (view def StateTransitionView)
+<style>
+root {
+  BackGroundColor white
+  FontName SansSerif
+  FontSize 14
+  FontColor black
+  LineColor #181818
+  HorizontalAlignment left
+}
+element {
+  BackGroundColor white
+  LineColor #181818
+  LineThickness 0.5
+  RoundCorner 0
+  Shadowing 0.0
+}
+start, end, activityBar {
+  BackGroundColor black
+}
+arrow {
+  LineColor #181818
+  LineThickness 1
+  FontSize 13
+}
+note {
+  BackGroundColor #FEFFDD
+  FontSize 13
+}
+.usage {
+  RoundCorner 20
+}
+.package {
+  LineThickness 1.5
+}
+.region {
+  LineStyle 4
+}
+</style>
+skinparam wrapWidth 300
+hide stereotype
+hide empty description
+state "<size:10>//«state def»//</size>\n**VehicleStates**" as n0 <<state def>> [[https://example.test/src/state.sysml#L8]] {
+  state "<size:10>//«state»//</size>\n**off**\ninitial" as n1 <<state>> <<usage>> [[https://example.test/src/state.sysml#L13]]
+  state "<size:10>//«state»//</size>\n**operating**" as n2 <<state>> <<usage>> [[https://example.test/src/state.sysml#L14]] {
+    state "<size:10>//«state»//</size>\n**idle**\ninitial" as n3 <<state>> <<usage>> [[https://example.test/src/state.sysml#L17]]
+    state "<size:10>//«state»//</size>\n**moving**" as n4 <<state>> <<usage>> [[https://example.test/src/state.sysml#L18]]
+    [*] --> n3
+  }
+  [*] --> n1
+}
+n1 --> n2 : [[https://example.test/src/state.sysml#L29]]
+n2 --> n1 : [[https://example.test/src/state.sysml#L30]]
+n3 --> n4 : accept Signal [temperature <U+003E> 0] [[https://example.test/src/state.sysml#L20]]
+n4 --> n3 : [[https://example.test/src/state.sysml#L26]]
+@enduml
diff --git a/internal/ir/view/testdata/links-tree-dot.golden b/internal/ir/view/testdata/links-tree-dot.golden
new file mode 100644
index 0000000000..3623ef243f
--- /dev/null
+++ b/internal/ir/view/testdata/links-tree-dot.golden
@@ -0,0 +1,22 @@
+// view: VehicleViews::vehicleView
+// kind: tree
+// layout: dot
+digraph "VehicleViews::vehicleView" {
+  graph [fontname="Helvetica"];
+  node [shape=box, style=filled, fillcolor=white, color="#181818", fontname="Helvetica", fontsize=14, penwidth=0.5];
+  edge [color="#181818", fontname="Helvetica", fontsize=13, penwidth=1];
+  "n0" [label=<<font point-size="10"><i>«part def»</i></font><br/><b>Vehicles::Vehicle</b>>, URL="https://example.test/src/tree.sysml#L11", tooltip="Vehicles::Vehicle"];
+  "n1" [style="rounded,filled", label=<<font point-size="10"><i>«part»</i></font><br/><b>engine : Engine</b>>, URL="https://example.test/src/tree.sysml#L12", tooltip="Vehicles::Vehicle::engine"];
+  "n0" -> "n1" [arrowhead=none];
+  "n2" [style="rounded,filled", label=<<font point-size="10"><i>«part»</i></font><br/><b>wheels : Wheel</b>>, URL="https://example.test/src/tree.sysml#L13", tooltip="Vehicles::Vehicle::wheels"];
+  "n0" -> "n2" [arrowhead=none];
+  "n3" [style="rounded,filled", label=<<b>connect</b>>, URL="https://example.test/src/tree.sysml#L14", tooltip="tree.sysml:14:3"];
+  "n0" -> "n3" [arrowhead=none];
+  "n4" [style="rounded,filled", label=<<font point-size="10"><i>«view»</i></font><br/><b>VehicleViews::vehicleView::engineSubview</b>>, URL="https://example.test/src/tree.sysml#L29", tooltip="VehicleViews::vehicleView::engineSubview"];
+  "n5" [label=<<font point-size="10"><i>«part def»</i></font><br/><b>Vehicles::Engine</b>>, URL="https://example.test/src/tree.sysml#L4", tooltip="Vehicles::Engine"];
+  "n6" [style="rounded,filled", label=<<font point-size="10"><i>«attribute»</i></font><br/><b>power</b>>, URL="https://example.test/src/tree.sysml#L5", tooltip="Vehicles::Engine::power"];
+  "n5" -> "n6" [arrowhead=none];
+  "n7" [style="rounded,filled", label=<<font point-size="10"><i>«part»</i></font><br/><b>cylinder : Cylinder</b>>, URL="https://example.test/src/tree.sysml#L6", tooltip="Vehicles::Engine::cylinder"];
+  "n5" -> "n7" [arrowhead=none];
+  "n4" -> "n5" [arrowhead=none];
+}
diff --git a/internal/ir/view/testdata/links-tree-mermaid.golden b/internal/ir/view/testdata/links-tree-mermaid.golden
new file mode 100644
index 0000000000..31b2798686
--- /dev/null
+++ b/internal/ir/view/testdata/links-tree-mermaid.golden
@@ -0,0 +1,54 @@
+---
+config:
+  fontFamily: "Helvetica, Arial, sans-serif"
+  theme: base
+  themeCSS: ".edgeLabel rect { opacity: 1 !important; } .cluster-label .nodeLabel { text-align: center; }"
+  themeVariables:
+    fontFamily: "Helvetica, Arial, sans-serif"
+    fontSize: "14px"
+    primaryColor: "#FFFFFF"
+    secondaryColor: "#FFFFFF"
+    tertiaryColor: "#FFFFFF"
+    background: "#FFFFFF"
+    primaryBorderColor: "#181818"
+    primaryTextColor: "#000000"
+    lineColor: "#181818"
+    textColor: "#000000"
+    noteBkgColor: "#FEFFDD"
+    noteBorderColor: "#181818"
+    noteTextColor: "#000000"
+    clusterBkg: "#FFFFFF"
+    clusterBorder: "#181818"
+    edgeLabelBackground: "#FFFFFF"
+---
+%% VehicleViews::vehicleView — tree rendering
+flowchart TD
+  n0["`*«part def»*
+**Vehicles::Vehicle**`"]
+    n1("`*«part»*
+**engine : Engine**`")
+  n0 --- n1
+    n2("`*«part»*
+**wheels : Wheel**`")
+  n0 --- n2
+    n3("`**connect**`")
+  n0 --- n3
+  n4("`*«view»*
+**VehicleViews::vehicleView::engineSubview**`")
+    n5["`*«part def»*
+**Vehicles::Engine**`"]
+      n6("`*«attribute»*
+**power**`")
+  n5 --- n6
+      n7("`*«part»*
+**cylinder : Cylinder**`")
+  n5 --- n7
+  n4 --- n5
+  click n0 href "https://example.test/src/tree.sysml#L11"
+  click n1 href "https://example.test/src/tree.sysml#L12"
+  click n2 href "https://example.test/src/tree.sysml#L13"
+  click n3 href "https://example.test/src/tree.sysml#L14"
+  click n4 href "https://example.test/src/tree.sysml#L29"
+  click n5 href "https://example.test/src/tree.sysml#L4"
+  click n6 href "https://example.test/src/tree.sysml#L5"
+  click n7 href "https://example.test/src/tree.sysml#L6"
diff --git a/internal/ir/view/testdata/links-tree-plantuml.golden b/internal/ir/view/testdata/links-tree-plantuml.golden
new file mode 100644
index 0000000000..00e5b3ccac
--- /dev/null
+++ b/internal/ir/view/testdata/links-tree-plantuml.golden
@@ -0,0 +1,59 @@
+@startuml
+' VehicleViews::vehicleView — tree rendering
+<style>
+root {
+  BackGroundColor white
+  FontName SansSerif
+  FontSize 14
+  FontColor black
+  LineColor #181818
+  HorizontalAlignment left
+}
+element {
+  BackGroundColor white
+  LineColor #181818
+  LineThickness 0.5
+  RoundCorner 0
+  Shadowing 0.0
+}
+start, end, activityBar {
+  BackGroundColor black
+}
+arrow {
+  LineColor #181818
+  LineThickness 1
+  FontSize 13
+}
+note {
+  BackGroundColor #FEFFDD
+  FontSize 13
+}
+.usage {
+  RoundCorner 20
+}
+.package {
+  LineThickness 1.5
+}
+.region {
+  LineStyle 4
+}
+</style>
+skinparam wrapWidth 300
+hide stereotype
+hide circle
+hide empty members
+class "<size:10>//«part def»//</size>\n**Vehicles::Vehicle**" as n0 <<part def>> [[https://example.test/src/tree.sysml#L11]]
+class "<size:10>//«part»//</size>\n**engine : Engine**" as n1 <<part>> <<usage>> [[https://example.test/src/tree.sysml#L12]]
+n0 -- n1
+class "<size:10>//«part»//</size>\n**wheels : Wheel**" as n2 <<part>> <<usage>> [[https://example.test/src/tree.sysml#L13]]
+n0 -- n2
+class "**connect**" as n3 <<connect>> <<usage>> [[https://example.test/src/tree.sysml#L14]]
+n0 -- n3
+class "<size:10>//«view»//</size>\n**VehicleViews::vehicleView::engineSubview**" as n4 <<view>> <<usage>> [[https://example.test/src/tree.sysml#L29]]
+class "<size:10>//«part def»//</size>\n**Vehicles::Engine**" as n5 <<part def>> [[https://example.test/src/tree.sysml#L4]]
+class "<size:10>//«attribute»//</size>\n**power**" as n6 <<attribute>> <<usage>> [[https://example.test/src/tree.sysml#L5]]
+n5 -- n6
+class "<size:10>//«part»//</size>\n**cylinder : Cylinder**" as n7 <<part>> <<usage>> [[https://example.test/src/tree.sysml#L6]]
+n5 -- n7
+n4 -- n5
+@enduml
diff --git a/internal/workspace/model/reading.go b/internal/workspace/model/reading.go
index b49a9ecb63..0406443919 100644
--- a/internal/workspace/model/reading.go
+++ b/internal/workspace/model/reading.go
@@ -50,6 +50,23 @@ func (r *Reading) SourceText() view.SourceText { return r.w.sourceText() }
 // Document is the held document name, nil for one the workspace does not hold.
 func (r *Reading) Document(name string) *Document { return r.w.docs[name] }
 
+// LineIndex is the held document's line index, nil when the workspace does not hold it.
+func (r *Reading) LineIndex(name string) *source.LineIndex {
+	if doc := r.Document(name); doc != nil {
+		return doc.Lines()
+	}
+	return nil
+}
+
+// LineIndexes snapshots the line indexes of the held documents.
+func (r *Reading) LineIndexes() map[string]*source.LineIndex {
+	indexes := make(map[string]*source.LineIndex, len(r.w.docs))
+	for name, doc := range r.w.docs {
+		indexes[name] = doc.Lines()
+	}
+	return indexes
+}
+
 // Declared is the element fqn names in doc: by qualified name in the index, else
 // by qualified or simple name among the document's own declarations.
 func (r *Reading) Declared(doc, fqn string) *symbols.Symbol {
diff --git a/internal/workspace/model/render.go b/internal/workspace/model/render.go
index 78e7aeba87..b64e5c1a94 100644
--- a/internal/workspace/model/render.go
+++ b/internal/workspace/model/render.go
@@ -89,6 +89,7 @@ type Snapshot struct {
 	// Rendered is the document the rendering was asked of.
 	Rendered *Document
 	docs     map[string]*Document
+	sites    map[view.Origin]view.Site
 }
 
 // Document is the named document as the snapshot holds it; nil for a name the
@@ -97,6 +98,18 @@ func (s *Snapshot) Document(name string) *Document {
 	return s.docs[name]
 }
 
+// Sites returns the source locations for the rendering's origins.
+func (s *Snapshot) Sites() view.Sites {
+	if s == nil || s.sites == nil {
+		return nil
+	}
+	sites := s.sites
+	return func(origin view.Origin) (view.Site, bool) {
+		site, ok := sites[origin]
+		return site, ok
+	}
+}
+
 // RenderView renders a view of a document. fqn names a declared view or a
 // pseudo-view (`#<kind>[:<fqn>]`); "" renders the document's own view. The
 // snapshot returned holds the documents the rendering was made from, read under
@@ -107,6 +120,48 @@ func (w *Workspace) RenderView(doc, fqn string) (*view.Rendering, *Snapshot, err
 	return w.renderViewLocked(doc, fqn)
 }
 
+// RenderViewLinked renders a view and resolves its source sites under the
+// workspace lock, so the returned snapshot can be used after the lock is released.
+func (w *Workspace) RenderViewLinked(doc, fqn string) (*view.Rendering, *Snapshot, error) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	rendering, snapshot, err := w.renderViewLocked(doc, fqn)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resolver, sem := w.semanticsLocked()
+	renderer := view.NewRenderer(sem, resolver, w.sourceText())
+	sites := renderer.Sites(view.FileLocator(sem, func(name string) *source.LineIndex {
+		if doc := snapshot.docs[name]; doc != nil {
+			return doc.Lines()
+		}
+		return nil
+	}))
+	frozen := make(map[view.Origin]view.Site)
+	add := func(origin view.Origin) {
+		if site, ok := sites(origin); ok {
+			frozen[origin] = site
+		}
+	}
+	var visit func([]*view.Node)
+	visit = func(nodes []*view.Node) {
+		for _, node := range nodes {
+			add(node.Origin)
+			for _, port := range node.Ports {
+				add(port.Origin)
+			}
+			visit(node.Children)
+		}
+	}
+	visit(rendering.Roots)
+	for _, edge := range rendering.Edges {
+		add(edge.Origin)
+	}
+	snapshot.sites = frozen
+	return rendering, snapshot, nil
+}
+
 // renderViewLocked is RenderView under the lock.
 func (w *Workspace) renderViewLocked(doc, fqn string) (*view.Rendering, *Snapshot, error) {
 	d := w.docs[doc]
@@ -121,7 +176,8 @@ func (w *Workspace) renderViewLocked(doc, fqn string) (*view.Rendering, *Snapsho
 	if err != nil {
 		return nil, nil, err
 	}
-	return rendering, &Snapshot{Rendered: d, docs: maps.Clone(w.docs)}, nil
+	snapshot := &Snapshot{Rendered: d, docs: maps.Clone(w.docs)}
+	return rendering, snapshot, nil
 }
 
 // renderDocumentViewLocked renders fqn of the held document d, as a query owned by d.
diff --git a/internal/workspace/model/render_test.go b/internal/workspace/model/render_test.go
index 7b0dcf3669..90148314e2 100644
--- a/internal/workspace/model/render_test.go
+++ b/internal/workspace/model/render_test.go
@@ -162,6 +162,9 @@ func TestRenderViewSnapshotHoldsEveryDocumentAsRendered(t *testing.T) {
 	if err != nil {
 		t.Fatalf("render: %v", err)
 	}
+	if snapshot.Sites() != nil {
+		t.Error("plain RenderView returned source sites")
+	}
 	if snapshot.Rendered != ws.Document("views.sysml") {
 		t.Error("Rendered is not the document the rendering was asked of")
 	}
@@ -194,6 +197,95 @@ func TestRenderViewSnapshotHoldsEveryDocumentAsRendered(t *testing.T) {
 	}
 }
 
+func TestRenderViewLinkedFreezesNodePortAndEdgeSites(t *testing.T) {
+	const model = `package Plant {
+	port def FluidPort;
+	item def Water;
+	part def Pump {
+		port outlet : FluidPort;
+		out item waterOut : Water;
+	}
+	part def Tank {
+		port inlet : FluidPort;
+		in item waterIn : Water;
+	}
+	part def Loop {
+		part pump : Pump;
+		part tank : Tank;
+		connection supply : Connection connect pump.outlet to tank.inlet;
+		flow of Water from pump.waterOut to tank.waterIn;
+	}
+	connection def Connection;
+}
+package PlantViews {
+	private import Views::*;
+	view loopView {
+		expose Plant::Loop;
+		render asInterconnectionDiagram;
+	}
+}
+`
+	ws := openDoc(t, "linked.sysml", model)
+	if _, plain, err := ws.RenderView("linked.sysml", "PlantViews::loopView"); err != nil {
+		t.Fatalf("plain render: %v", err)
+	} else if plain.Sites() != nil {
+		t.Fatal("plain RenderView returned source sites")
+	}
+
+	rendering, snapshot, err := ws.RenderViewLinked("linked.sysml", "PlantViews::loopView")
+	if err != nil {
+		t.Fatalf("linked render: %v", err)
+	}
+	sites := snapshot.Sites()
+	if sites == nil {
+		t.Fatal("RenderViewLinked returned no source sites")
+	}
+
+	want := map[view.Origin]view.Site{}
+	counts := map[string]int{}
+	check := func(origin view.Origin, kind string) {
+		if !origin.Located() || origin.Doc != "linked.sysml" {
+			return
+		}
+		site, ok := sites(origin)
+		if !ok {
+			t.Errorf("%s origin %+v has no frozen site", kind, origin)
+			return
+		}
+		if site.File != "linked.sysml" || site.Line < 1 || site.Col < 1 {
+			t.Errorf("%s site = %+v, want a file and source position", kind, site)
+		}
+		want[origin] = site
+		counts[kind]++
+	}
+	var visit func([]*view.Node)
+	visit = func(nodes []*view.Node) {
+		for _, node := range nodes {
+			check(node.Origin, "node")
+			for _, port := range node.Ports {
+				check(port.Origin, "port")
+			}
+			visit(node.Children)
+		}
+	}
+	visit(rendering.Roots)
+	for _, edge := range rendering.Edges {
+		check(edge.Origin, "edge")
+	}
+	for _, kind := range []string{"node", "port", "edge"} {
+		if counts[kind] == 0 {
+			t.Errorf("rendering had no located %s origins", kind)
+		}
+	}
+
+	ws.Update("linked.sysml", []byte("// newer workspace generation\n"+model), 2)
+	for origin, wantSite := range want {
+		if got, ok := sites(origin); !ok || got != wantSite {
+			t.Errorf("frozen site for %+v = %+v, %t; want %+v, true", origin, got, ok, wantSite)
+		}
+	}
+}
+
 // A transition a usage inherits from a definition in another document is
 // located there and labelled with its trigger and guard as written there.
 func TestRenderViewLocatesInheritedTransitionsInTheirDocument(t *testing.T) {
diff --git a/internal/workspace/modeldoc/modeldoc.go b/internal/workspace/modeldoc/modeldoc.go
index ade3a66fe4..3209f3779f 100644
--- a/internal/workspace/modeldoc/modeldoc.go
+++ b/internal/workspace/modeldoc/modeldoc.go
@@ -66,10 +66,13 @@ func RenderDocumentMarkdown(ws *model.Workspace, fqn string, opts docrender.Mark
 			if opts.Files, err = DocumentFiles(model.DocumentNames(idx, sem), ".md"); err != nil {
 				return
 			}
+			lineIndexes := r.LineIndexes()
 			var document *docir.Document
 			document, err = docir.EvaluateLinked(plan,
 				model.SiblingDocumentPlans(idx, sem, resolver, sym),
-				queryexec.Context{Index: idx, Resolver: resolver, Model: sem},
+				queryexec.Context{Index: idx, Resolver: resolver, Model: sem, LineIndex: func(doc string) *source.LineIndex {
+					return lineIndexes[doc]
+				}},
 				queryexec.Options{}, r.SourceText())
 			if err != nil {
 				return
diff --git a/packaging/man/man1/sysml.1 b/packaging/man/man1/sysml.1
index 3a83d8ec27..4479f3d476 100644
--- a/packaging/man/man1/sysml.1
+++ b/packaging/man/man1/sysml.1
@@ -310,6 +310,11 @@ Palette the dot, mermaid 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\-link " \fItemplate\fP"
+Link template for rendered elements: {file} is the path as loaded; use
+absolute paths for vscode:// or file:// links. Placeholders: {file}, {line},
+{col}, {qname}, {id}
+.TP
 .BR \-render\-unplaced " \fIplacement\fP"
 Where a graph form of a view some Layout positions puts the nodes none does:
 omit (default) leaves them undrawn in every form, strip draws them, in rows