diff --git a/docs/pvm-spec.md b/docs/pvm-spec.md
index db717de4..4d68e68f 100644
--- a/docs/pvm-spec.md
+++ b/docs/pvm-spec.md
@@ -23,6 +23,7 @@ This document is the authoritative reference for anyone building tools that read
   - [4.1 Subsystem Node](#41-subsystem-node)
   - [4.2 Interface Node](#42-interface-node)
   - [4.3 Nesting](#43-nesting)
+  - [4.4 Buses](#44-buses)
 - [5. Events](#5-events)
 - [6. Code Context](#6-code-context)
 - [7. Simulation Settings](#7-simulation-settings)
@@ -301,6 +302,26 @@ Subsystems can be nested arbitrarily deep. A subsystem's `graph.nodes` can conta
 
 In PathSim Python code, subsystems map to `Subsystem(blocks=[...], connections=[...])` constructors. The Interface maps to `Interface()`. See `scripts/pvm2py.py` for a reference implementation.
 
+### 4.4 Buses
+
+`BusCreator` and `BusSelector` nodes group signals into one wire. They exist only in the editor: code generators resolve them before generating code and never emit them.
+
+| Node type | Ports | Params |
+|-----------|-------|--------|
+| `BusCreator` | Any number of inputs, one output carrying the bus. | none |
+| `BusSelector` | One input taking a bus, one output per picked signal. | `signals`: array of signal paths, one per output. |
+
+**Signal names.** Each Bus Creator input becomes a named element of the bus: the `label` of the incoming connection, else the name of the source port, else the input port name. Dots are replaced by underscores and repeated names get `_2`, `_3`, and so on. A bus fed into a Bus Creator becomes a nested bus; its signals are addressed with dotted paths such as `inner.b`. A path naming a nested bus selects the whole nested bus.
+
+**Resolution.** Code generators rewrite the model before generating code:
+
+- Bus Creator and Bus Selector nodes are removed, together with the connections into them.
+- Each connection out of a Bus Selector output is wired from the original source of the picked signal.
+- A subsystem port carrying a bus becomes one port index per leaf signal, in bus order, on the Subsystem and on its Interface. Port indices after it shift accordingly.
+- Wiring that cannot be resolved is left out: a bus into a block that is not a bus block or subsystem, a picked signal missing from the bus, or a wire loop through bus blocks.
+
+The reference implementations are `src/lib/bus/expand.ts` and `pathview/buses.py`; `tests/fixtures/bus_expansion.json` lists the expected wiring for each case.
+
 ---
 
 ## 5. Events
diff --git a/pathview/buses.py b/pathview/buses.py
new file mode 100644
index 00000000..904f3460
--- /dev/null
+++ b/pathview/buses.py
@@ -0,0 +1,345 @@
+"""Buses: virtual Bus Creator and Bus Selector blocks.
+
+A Bus Creator bundles its input signals into one bus signal, a Bus Selector
+picks signals out of a bus by name. Both exist only in the editor. Before code
+generation the model is rewritten without them: every picked signal is wired
+directly from its source, and a subsystem port carrying a bus becomes one port
+index per signal in the bus. Subsystem and Interface have no fixed port count
+in pathsim, so only the port indices of connections change.
+
+Mirrors src/lib/bus/expand.ts; tests/fixtures/bus_expansion.json keeps both
+implementations in agreement.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+BUS_CREATOR = "BusCreator"
+BUS_SELECTOR = "BusSelector"
+SUBSYSTEM = "Subsystem"
+INTERFACE = "Interface"
+SEPARATOR = "."
+
+# A signal structure is None for a plain signal, else a list of (name, structure) elements
+
+
+def is_bus_block(node: dict) -> bool:
+    return node.get("type") in (BUS_CREATOR, BUS_SELECTOR)
+
+
+def selected_signals(node: dict) -> list[str]:
+    """Signal paths a Bus Selector picks, one per output."""
+    value = (node.get("params") or {}).get("signals")
+    return [str(v) for v in value] if isinstance(value, list) else []
+
+
+def signal_leaves(structure) -> list[str]:
+    """Leaf signal paths of a structure; a plain signal has the single empty path."""
+    if structure is None:
+        return [""]
+    leaves = []
+    for name, sub in structure:
+        for path in signal_leaves(sub):
+            leaves.append(f"{name}{SEPARATOR}{path}" if path else name)
+    return leaves
+
+
+def element_at(structure, path: str):
+    """Structure of the element at a dotted signal path, and whether it exists."""
+    current = structure
+    found = False
+    for name in path.split(SEPARATOR):
+        match = next((sub for element, sub in (current or []) if element == name), _MISSING)
+        if match is _MISSING:
+            return False, None
+        current = match
+        found = True
+    return found, current
+
+
+_MISSING = object()
+
+
+def _contains_bus_blocks(nodes: list[dict]) -> bool:
+    return any(
+        is_bus_block(n) or (bool(n.get("graph")) and _contains_bus_blocks(n["graph"].get("nodes", [])))
+        for n in nodes
+    )
+
+
+@dataclass(eq=False)
+class BusLevel:
+    """One graph level: the root graph or the graph inside a subsystem."""
+
+    id: int
+    node_list: list[dict]
+    nodes: dict[str, dict]
+    connections: list[dict]
+    incoming: dict[str, dict]
+    parent: tuple[BusLevel, dict] | None
+    children: dict[str, BusLevel] = field(default_factory=dict)
+
+
+class BusModel:
+    """Signal structures of a whole model, following wires through bus blocks and subsystems."""
+
+    def __init__(self, nodes: list[dict], connections: list[dict]):
+        self._next_id = 0
+        self._memo: dict[str, object] = {}
+        self._visiting: set[str] = set()
+        self.root = self._build_level(nodes, connections, None)
+
+    def _build_level(self, node_list, connections, parent) -> BusLevel:
+        level = BusLevel(
+            id=self._next_id,
+            node_list=node_list,
+            nodes={n["id"]: n for n in node_list},
+            connections=connections,
+            incoming={f"{c['targetNodeId']}:{c['targetPortIndex']}": c for c in connections},
+            parent=parent,
+        )
+        self._next_id += 1
+        for node in node_list:
+            graph = node.get("graph")
+            if node.get("type") == SUBSYSTEM and graph:
+                level.children[node["id"]] = self._build_level(
+                    graph.get("nodes", []), graph.get("connections", []), (level, node)
+                )
+        return level
+
+    def level_at(self, path: list[str]) -> BusLevel | None:
+        level = self.root
+        for node_id in path:
+            level = level.children.get(node_id)
+            if level is None:
+                return None
+        return level
+
+    def _source_port_name(self, level: BusLevel, connection: dict) -> str | None:
+        source = level.nodes.get(connection["sourceNodeId"])
+        port = connection["sourcePortIndex"]
+        if source is not None and source.get("type") == INTERFACE and level.parent:
+            ports = level.parent[1].get("inputs", [])
+        else:
+            ports = (source or {}).get("outputs", [])
+        return ports[port].get("name") if port < len(ports) else None
+
+    def _element_names(self, level: BusLevel, creator: dict) -> list[str]:
+        """Wire label, else source port name, else the creator's input name; unique."""
+        used: set[str] = set()
+        names = []
+        for i, port in enumerate(creator.get("inputs", [])):
+            connection = level.incoming.get(f"{creator['id']}:{i}")
+            label = (connection.get("label") or "").strip() if connection else ""
+            source_name = self._source_port_name(level, connection) if connection else None
+            raw = label or source_name or port.get("name") or f"signal {i}"
+            base = "_".join(raw.split(SEPARATOR))
+            name = base
+            n = 2
+            while name in used:
+                name = f"{base}_{n}"
+                n += 1
+            used.add(name)
+            names.append(name)
+        return names
+
+    def structure_in(self, level: BusLevel, node_id: str, port: int):
+        connection = level.incoming.get(f"{node_id}:{port}")
+        if connection is None:
+            return None
+        return self.structure_out(level, connection["sourceNodeId"], connection["sourcePortIndex"])
+
+    def structure_out(self, level: BusLevel, node_id: str, port: int):
+        key = f"{level.id}:{node_id}:{port}"
+        if key in self._memo:
+            return self._memo[key]
+        # A wire loop through bus blocks has no defined structure
+        if key in self._visiting:
+            return None
+        self._visiting.add(key)
+        structure = self._compute_out(level, node_id, port)
+        self._visiting.discard(key)
+        self._memo[key] = structure
+        return structure
+
+    def _compute_out(self, level: BusLevel, node_id: str, port: int):
+        node = level.nodes.get(node_id)
+        if node is None:
+            return None
+        kind = node.get("type")
+        if kind == BUS_CREATOR:
+            return [
+                (name, self.structure_in(level, node_id, i))
+                for i, name in enumerate(self._element_names(level, node))
+            ]
+        if kind == BUS_SELECTOR:
+            paths = selected_signals(node)
+            if port >= len(paths) or not paths[port]:
+                return None
+            return element_at(self.structure_in(level, node_id, 0), paths[port])[1]
+        if kind == SUBSYSTEM:
+            inner = level.children.get(node_id)
+            iface = next((n for n in inner.node_list if n.get("type") == INTERFACE), None) if inner else None
+            return self.structure_in(inner, iface["id"], port) if iface else None
+        if kind == INTERFACE and level.parent:
+            outer, subsystem = level.parent
+            return self.structure_in(outer, subsystem["id"], port)
+        return None
+
+
+def expand_buses(nodes: list[dict], connections: list[dict]) -> tuple[list[dict], list[dict]]:
+    """The model without bus blocks, for code generation.
+
+    Models without bus blocks are returned unchanged. Connections that carry
+    several signals are split, with IDs suffixed by the signal index. Wiring
+    that cannot be resolved, such as a bus into a plain block or a signal
+    missing from a bus, is left out.
+    """
+    if not _contains_bus_blocks(nodes):
+        return nodes, connections
+    return _Expansion(BusModel(nodes, connections)).expand()
+
+
+class _Expansion:
+    def __init__(self, model: BusModel):
+        self.model = model
+        self._offsets: dict[str, list[int]] = {}
+        self._resolving: set[str] = set()
+
+    @staticmethod
+    def _count(structure) -> int:
+        return len(signal_leaves(structure))
+
+    @staticmethod
+    def _range(node_id: str, offset: int, length: int) -> list[tuple[str, int] | None]:
+        return [(node_id, offset + j) for j in range(length)]
+
+    def _offsets_of(self, level: BusLevel, subsystem: dict, direction: str) -> list[int]:
+        key = f"{level.id}:{subsystem['id']}:{direction}"
+        if key in self._offsets:
+            return self._offsets[key]
+        ports = len(subsystem.get("inputs" if direction == "in" else "outputs", []))
+        result = []
+        total = 0
+        for i in range(ports):
+            result.append(total)
+            if direction == "in":
+                total += self._count(self.model.structure_in(level, subsystem["id"], i))
+            else:
+                total += self._count(self.model.structure_out(level, subsystem["id"], i))
+        self._offsets[key] = result
+        return result
+
+    def _offset(self, level: BusLevel, subsystem: dict, direction: str, port: int) -> int:
+        offsets = self._offsets_of(level, subsystem, direction)
+        return offsets[port] if port < len(offsets) else port
+
+    def _resolve_in(self, level: BusLevel, node_id: str, port: int):
+        connection = level.incoming.get(f"{node_id}:{port}")
+        if connection is None:
+            return [None]
+        return self._resolve_out(level, connection["sourceNodeId"], connection["sourcePortIndex"])
+
+    def _resolve_out(self, level: BusLevel, node_id: str, port: int):
+        """Real source of every signal leaving an output, in leaf order."""
+        key = f"{level.id}:{node_id}:{port}"
+        if key in self._resolving:
+            return [None]
+        self._resolving.add(key)
+        endpoints = self._compute_resolve_out(level, node_id, port)
+        self._resolving.discard(key)
+        return endpoints
+
+    def _compute_resolve_out(self, level: BusLevel, node_id: str, port: int):
+        model = self.model
+        node = level.nodes.get(node_id)
+        if node is None:
+            return [None]
+        kind = node.get("type")
+        if kind == BUS_CREATOR:
+            return [e for i in range(len(node.get("inputs", []))) for e in self._resolve_in(level, node_id, i)]
+        if kind == BUS_SELECTOR:
+            paths = selected_signals(node)
+            path = paths[port] if port < len(paths) else ""
+            everything = self._resolve_in(level, node_id, 0)
+            leaves = signal_leaves(model.structure_in(level, node_id, 0))
+            picked = []
+            if path:
+                for i, leaf in enumerate(leaves):
+                    if leaf == path or leaf.startswith(path + SEPARATOR):
+                        picked.append(everything[i] if i < len(everything) else None)
+            return picked or [None]
+        if kind == SUBSYSTEM:
+            return self._range(
+                node_id, self._offset(level, node, "out", port), self._count(model.structure_out(level, node_id, port))
+            )
+        if kind == INTERFACE:
+            if not level.parent:
+                return [(node_id, port)]
+            outer, subsystem = level.parent
+            return self._range(
+                node_id,
+                self._offset(outer, subsystem, "in", port),
+                self._count(model.structure_in(outer, subsystem["id"], port)),
+            )
+        return [(node_id, port)]
+
+    def _input_slots(self, level: BusLevel, node: dict, port: int):
+        """Expanded input slots a connection into a port lands on; bus blocks take none."""
+        model = self.model
+        kind = node.get("type")
+        if kind in (BUS_CREATOR, BUS_SELECTOR):
+            return []
+        if kind == SUBSYSTEM:
+            return self._range(
+                node["id"], self._offset(level, node, "in", port), self._count(model.structure_in(level, node["id"], port))
+            )
+        if kind == INTERFACE and level.parent:
+            outer, subsystem = level.parent
+            return self._range(
+                node["id"],
+                self._offset(outer, subsystem, "out", port),
+                self._count(model.structure_out(outer, subsystem["id"], port)),
+            )
+        return [(node["id"], port)]
+
+    def expand(self) -> tuple[list[dict], list[dict]]:
+        return self._expand_level(self.model.root)
+
+    def _expand_level(self, level: BusLevel) -> tuple[list[dict], list[dict]]:
+        nodes = []
+        for node in level.node_list:
+            if is_bus_block(node):
+                continue
+            inner = level.children.get(node["id"])
+            if inner is not None and node.get("graph"):
+                child_nodes, child_connections = self._expand_level(inner)
+                nodes.append({**node, "graph": {**node["graph"], "nodes": child_nodes, "connections": child_connections}})
+            else:
+                nodes.append(node)
+
+        connections = []
+        for connection in level.connections:
+            target = level.nodes.get(connection["targetNodeId"])
+            if target is None or connection["sourceNodeId"] not in level.nodes:
+                connections.append(connection)
+                continue
+            targets = self._input_slots(level, target, connection["targetPortIndex"])
+            if not targets:
+                continue
+            sources = self._resolve_out(level, connection["sourceNodeId"], connection["sourcePortIndex"])
+            if len(sources) != len(targets):
+                continue
+            for i, (source, slot) in enumerate(zip(sources, targets)):
+                if source is None or slot is None:
+                    continue
+                connections.append({
+                    **connection,
+                    "id": connection["id"] if len(sources) == 1 else f"{connection['id']}{SEPARATOR}{i}",
+                    "sourceNodeId": source[0],
+                    "sourcePortIndex": source[1],
+                    "targetNodeId": slot[0],
+                    "targetPortIndex": slot[1],
+                })
+        return nodes, connections
diff --git a/pathview/converter.py b/pathview/converter.py
index 1dd613c7..a8e13edc 100644
--- a/pathview/converter.py
+++ b/pathview/converter.py
@@ -16,6 +16,8 @@
 from pathlib import Path
 from typing import Any
 
+from pathview.buses import expand_buses
+
 
 # =============================================================================
 # Registry
@@ -322,8 +324,8 @@ def generate_python(pvm: dict, registry: dict, source_name: str = "") -> str:
     divider = "# " + "\u2500" * 76
 
     graph = pvm.get("graph", {})
-    nodes = graph.get("nodes", [])
-    connections = graph.get("connections", [])
+    # Bus Creator and Bus Selector exist only in the editor; wire their signals directly
+    nodes, connections = expand_buses(graph.get("nodes", []), graph.get("connections", []))
     events = pvm.get("events", [])
     code_context = pvm.get("codeContext", {}).get("code", "")
     settings = pvm.get("simulationSettings", {})
diff --git a/src/app.css b/src/app.css
index 85c5edae..6efbeaf9 100644
--- a/src/app.css
+++ b/src/app.css
@@ -603,6 +603,33 @@ input[type="checkbox"]:focus-visible {
 	padding: var(--space-md);
 }
 
+/* Bus Selector signal list; nested bus elements are indented by depth */
+.properties-dialog .signal-list {
+	display: flex;
+	flex-direction: column;
+	gap: var(--space-xs);
+}
+
+.properties-dialog .signal-item {
+	display: flex;
+	align-items: center;
+	gap: var(--space-sm);
+	padding-left: calc(var(--signal-depth, 0) * var(--space-lg));
+	font-size: 12px;
+	font-family: var(--font-mono);
+	color: var(--text);
+	cursor: pointer;
+}
+
+.properties-dialog .signal-item .bus-signal {
+	color: var(--text-muted);
+}
+
+.properties-dialog .signal-item.missing {
+	color: var(--text-disabled);
+	text-decoration: line-through;
+}
+
 .properties-dialog .dialog-footer {
 	padding: var(--space-sm) var(--space-md);
 	background: var(--surface-raised);
diff --git a/src/lib/bus/expand.test.ts b/src/lib/bus/expand.test.ts
new file mode 100644
index 00000000..0922952d
--- /dev/null
+++ b/src/lib/bus/expand.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import type { Connection, NodeInstance } from '$lib/types/nodes';
+import fixtures from '../../../tests/fixtures/bus_expansion.json';
+import { analyzeBuses, expandBuses, isBusBlock, signalLeaves } from './expand';
+
+type Scenario = (typeof fixtures.scenarios)[number];
+
+const wiring = (connections: Connection[]) =>
+	connections.map((c) => `${c.sourceNodeId}:${c.sourcePortIndex}>${c.targetNodeId}:${c.targetPortIndex}`).sort();
+
+/** Wiring per level, keyed by subsystem ID path */
+function levels(nodes: NodeInstance[], connections: Connection[], path = ''): Record<string, string[]> {
+	const result: Record<string, string[]> = { [path]: wiring(connections) };
+	for (const node of nodes) {
+		if (!node.graph) continue;
+		Object.assign(result, levels(node.graph.nodes, node.graph.connections, path ? `${path}/${node.id}` : node.id));
+	}
+	return result;
+}
+
+function anyBusBlock(nodes: NodeInstance[]): boolean {
+	return nodes.some((n) => isBusBlock(n) || (n.graph ? anyBusBlock(n.graph.nodes) : false));
+}
+
+function load(scenario: Scenario) {
+	return {
+		nodes: scenario.nodes as unknown as NodeInstance[],
+		connections: scenario.connections as unknown as Connection[]
+	};
+}
+
+describe('bus expansion', () => {
+	for (const scenario of fixtures.scenarios) {
+		it(scenario.name, () => {
+			const { nodes, connections } = load(scenario);
+			const expanded = expandBuses(nodes, connections);
+			const expected = Object.fromEntries(
+				Object.entries(scenario.expected as unknown as Record<string, string[]>).map(([key, value]) => [key, [...value].sort()])
+			);
+			expect(levels(expanded.nodes, expanded.connections)).toEqual(expected);
+			expect(anyBusBlock(expanded.nodes)).toBe(false);
+		});
+	}
+
+	it('returns a model without bus blocks as it is', () => {
+		const { nodes, connections } = load(fixtures.scenarios.find((s) => s.name.includes('without buses'))!);
+		const expanded = expandBuses(nodes, connections);
+		expect(expanded.nodes).toBe(nodes);
+		expect(expanded.connections).toBe(connections);
+	});
+
+	it('follows a bus structure into a subsystem', () => {
+		const { nodes, connections } = load(fixtures.scenarios.find((s) => s.name === 'bus into a subsystem')!);
+		const analysis = analyzeBuses(nodes, connections);
+		const inner = analysis.levelAt(['Sub'])!;
+		expect(signalLeaves(analysis.structureOut(inner, 'I', 0))).toEqual(['a', 'b']);
+		expect(signalLeaves(analysis.structureIn(analysis.root, 'Scope', 0))).toEqual(['']);
+	});
+});
diff --git a/src/lib/bus/expand.ts b/src/lib/bus/expand.ts
new file mode 100644
index 00000000..77b0450d
--- /dev/null
+++ b/src/lib/bus/expand.ts
@@ -0,0 +1,349 @@
+/**
+ * Buses - virtual Bus Creator and Bus Selector blocks
+ *
+ * A Bus Creator bundles its input signals into one bus signal, a Bus Selector
+ * picks signals out of a bus by name. Both exist only in the editor. Before code
+ * generation the model is rewritten without them: every picked signal is wired
+ * directly from its source, and a subsystem port carrying a bus becomes one port
+ * index per signal in the bus. Subsystem and Interface have no fixed port count
+ * in pathsim, so only the port indices of connections change.
+ *
+ * pathview/converter.py implements the same rules; tests/fixtures/bus_expansion.json
+ * keeps both implementations in agreement.
+ */
+
+import type { Connection, NodeInstance } from '$lib/types/nodes';
+import { NODE_TYPES } from '$lib/constants/nodeTypes';
+
+/** Signal structure: null for a plain signal, else the named elements of a bus */
+export type BusStructure = BusElement[] | null;
+
+export interface BusElement {
+	name: string;
+	structure: BusStructure;
+	/** Bus Creator input the element was bundled at, to follow renames */
+	origin?: { creatorId: string; input: number };
+}
+
+/** One graph level: the root graph or the graph inside a subsystem */
+export interface BusLevel {
+	id: number;
+	nodeList: NodeInstance[];
+	nodes: Map<string, NodeInstance>;
+	connections: Connection[];
+	/** Connection into each input, keyed by "nodeId:port" */
+	incoming: Map<string, Connection>;
+	/** Subsystem owning this level and the level the subsystem sits in */
+	parent: { level: BusLevel; subsystem: NodeInstance } | null;
+	/** Levels inside the subsystems of this level, by subsystem ID */
+	children: Map<string, BusLevel>;
+}
+
+type Endpoint = { nodeId: string; port: number } | null;
+
+/** Separator of the names in a signal path such as "inner.b" */
+export const SIGNAL_SEPARATOR = '.';
+const SEPARATOR = SIGNAL_SEPARATOR;
+
+/** Subsystem IDs from the root down to a level */
+export function levelPath(level: BusLevel): string[] {
+	return level.parent ? [...levelPath(level.parent.level), level.parent.subsystem.id] : [];
+}
+
+export function isBusBlock(node: NodeInstance): boolean {
+	return node.type === NODE_TYPES.BUS_CREATOR || node.type === NODE_TYPES.BUS_SELECTOR;
+}
+
+/** Signal paths a Bus Selector picks, one per output */
+export function selectedSignals(node: NodeInstance): string[] {
+	const value = node.params?.signals;
+	return Array.isArray(value) ? value.map(String) : [];
+}
+
+/** Leaf signal paths of a structure; a plain signal has the single empty path */
+export function signalLeaves(structure: BusStructure): string[] {
+	if (!structure) return [''];
+	return structure.flatMap((element) =>
+		signalLeaves(element.structure).map((path) => (path ? `${element.name}${SEPARATOR}${path}` : element.name))
+	);
+}
+
+/** Every signal path in a bus with its nesting depth; sub-buses come before their elements */
+export function signalPaths(structure: BusStructure): { path: string; depth: number; isBus: boolean }[] {
+	const paths: { path: string; depth: number; isBus: boolean }[] = [];
+	const walk = (elements: BusElement[], prefix: string, depth: number) => {
+		for (const element of elements) {
+			const path = prefix ? `${prefix}${SEPARATOR}${element.name}` : element.name;
+			paths.push({ path, depth, isBus: element.structure !== null });
+			if (element.structure) walk(element.structure, path, depth + 1);
+		}
+	};
+	if (structure) walk(structure, '', 0);
+	return paths;
+}
+
+/** Element at a dotted signal path */
+export function elementAt(structure: BusStructure, path: string): BusElement | undefined {
+	let current: BusElement | undefined;
+	let elements = structure;
+	for (const name of path.split(SEPARATOR)) {
+		current = elements?.find((e) => e.name === name);
+		if (!current) return undefined;
+		elements = current.structure;
+	}
+	return current;
+}
+
+export function containsBusBlocks(nodes: NodeInstance[]): boolean {
+	return nodes.some((n) => isBusBlock(n) || (n.graph ? containsBusBlocks(n.graph.nodes) : false));
+}
+
+/**
+ * Signal structures of a whole model. Structures follow wires through Bus
+ * Creators, Bus Selectors and subsystem boundaries in both directions.
+ */
+export function analyzeBuses(nodes: NodeInstance[], connections: Connection[]) {
+	let nextLevelId = 0;
+
+	function buildLevel(nodeList: NodeInstance[], levelConnections: Connection[], parent: BusLevel['parent']): BusLevel {
+		const level: BusLevel = {
+			id: nextLevelId++,
+			nodeList,
+			nodes: new Map(nodeList.map((n) => [n.id, n])),
+			connections: levelConnections,
+			incoming: new Map(levelConnections.map((c) => [`${c.targetNodeId}:${c.targetPortIndex}`, c])),
+			parent,
+			children: new Map()
+		};
+		for (const node of nodeList) {
+			if (node.type === NODE_TYPES.SUBSYSTEM && node.graph) {
+				level.children.set(node.id, buildLevel(node.graph.nodes, node.graph.connections, { level, subsystem: node }));
+			}
+		}
+		return level;
+	}
+
+	const root = buildLevel(nodes, connections, null);
+	const memo = new Map<string, BusStructure>();
+	const visiting = new Set<string>();
+
+	const interfaceOf = (level: BusLevel) => level.nodeList.find((n) => n.type === NODE_TYPES.INTERFACE);
+
+	/** Name of the port a connection comes from; Interface outputs take the owning subsystem's input names */
+	function sourcePortName(level: BusLevel, connection: Connection): string | undefined {
+		const source = level.nodes.get(connection.sourceNodeId);
+		if (source?.type === NODE_TYPES.INTERFACE && level.parent) {
+			return level.parent.subsystem.inputs[connection.sourcePortIndex]?.name;
+		}
+		return source?.outputs[connection.sourcePortIndex]?.name;
+	}
+
+	/** Element names of a Bus Creator: wire label, else source port name, else its own input name; unique */
+	function elementNames(level: BusLevel, creator: NodeInstance): string[] {
+		const used = new Set<string>();
+		return creator.inputs.map((input, i) => {
+			const connection = level.incoming.get(`${creator.id}:${i}`);
+			const raw =
+				connection?.label?.trim() || (connection && sourcePortName(level, connection)) || input.name || `signal ${i}`;
+			const base = raw.split(SEPARATOR).join('_');
+			let name = base;
+			for (let n = 2; used.has(name); n++) name = `${base}_${n}`;
+			used.add(name);
+			return name;
+		});
+	}
+
+	function structureIn(level: BusLevel, nodeId: string, port: number): BusStructure {
+		const connection = level.incoming.get(`${nodeId}:${port}`);
+		return connection ? structureOut(level, connection.sourceNodeId, connection.sourcePortIndex) : null;
+	}
+
+	function structureOut(level: BusLevel, nodeId: string, port: number): BusStructure {
+		const key = `${level.id}:${nodeId}:${port}`;
+		if (memo.has(key)) return memo.get(key)!;
+		// A wire loop through bus blocks has no defined structure
+		if (visiting.has(key)) return null;
+		visiting.add(key);
+		const structure = computeOut(level, nodeId, port);
+		visiting.delete(key);
+		memo.set(key, structure);
+		return structure;
+	}
+
+	function computeOut(level: BusLevel, nodeId: string, port: number): BusStructure {
+		const node = level.nodes.get(nodeId);
+		if (!node) return null;
+		switch (node.type) {
+			case NODE_TYPES.BUS_CREATOR:
+				return elementNames(level, node).map((name, i) => ({
+					name,
+					structure: structureIn(level, node.id, i),
+					origin: { creatorId: node.id, input: i }
+				}));
+			case NODE_TYPES.BUS_SELECTOR: {
+				const path = selectedSignals(node)[port];
+				return path ? (elementAt(structureIn(level, node.id, 0), path)?.structure ?? null) : null;
+			}
+			case NODE_TYPES.SUBSYSTEM: {
+				const inner = level.children.get(node.id);
+				const iface = inner && interfaceOf(inner);
+				return inner && iface ? structureIn(inner, iface.id, port) : null;
+			}
+			case NODE_TYPES.INTERFACE:
+				return level.parent ? structureIn(level.parent.level, level.parent.subsystem.id, port) : null;
+			default:
+				return null;
+		}
+	}
+
+	/** Level at a subsystem path from the root, by subsystem IDs */
+	function levelAt(path: string[]): BusLevel | null {
+		let level: BusLevel | undefined = root;
+		for (const id of path) {
+			level = level?.children.get(id);
+			if (!level) return null;
+		}
+		return level;
+	}
+
+	return { root, levelAt, structureIn, structureOut, elementNames };
+}
+
+/**
+ * The model without bus blocks, for code generation. Models without bus blocks
+ * are returned unchanged. Connections that carry several signals are split,
+ * with IDs suffixed by the signal index. Wiring that cannot be resolved, such
+ * as a bus into a plain block or a signal missing from a bus, is left out.
+ */
+export function expandBuses(
+	nodes: NodeInstance[],
+	connections: Connection[]
+): { nodes: NodeInstance[]; connections: Connection[] } {
+	if (!containsBusBlocks(nodes)) return { nodes, connections };
+
+	const { root, structureIn, structureOut } = analyzeBuses(nodes, connections);
+	const count = (structure: BusStructure) => signalLeaves(structure).length;
+	const range = (nodeId: string, offset: number, length: number): Endpoint[] =>
+		Array.from({ length }, (_, j) => ({ nodeId, port: offset + j }));
+
+	/** First expanded port index of each port of a subsystem */
+	const offsetMemo = new Map<string, number[]>();
+	function offsets(level: BusLevel, subsystem: NodeInstance, direction: 'in' | 'out'): number[] {
+		const key = `${level.id}:${subsystem.id}:${direction}`;
+		const known = offsetMemo.get(key);
+		if (known) return known;
+		const ports = direction === 'in' ? subsystem.inputs.length : subsystem.outputs.length;
+		const result: number[] = [];
+		let sum = 0;
+		for (let i = 0; i < ports; i++) {
+			result.push(sum);
+			sum += count(direction === 'in' ? structureIn(level, subsystem.id, i) : structureOut(level, subsystem.id, i));
+		}
+		offsetMemo.set(key, result);
+		return result;
+	}
+
+	const resolving = new Set<string>();
+
+	function resolveIn(level: BusLevel, nodeId: string, port: number): Endpoint[] {
+		const connection = level.incoming.get(`${nodeId}:${port}`);
+		return connection ? resolveOut(level, connection.sourceNodeId, connection.sourcePortIndex) : [null];
+	}
+
+	/** Real source of every signal leaving an output, in leaf order */
+	function resolveOut(level: BusLevel, nodeId: string, port: number): Endpoint[] {
+		const key = `${level.id}:${nodeId}:${port}`;
+		if (resolving.has(key)) return [null];
+		resolving.add(key);
+		const endpoints = computeResolveOut(level, nodeId, port);
+		resolving.delete(key);
+		return endpoints;
+	}
+
+	function computeResolveOut(level: BusLevel, nodeId: string, port: number): Endpoint[] {
+		const node = level.nodes.get(nodeId);
+		if (!node) return [null];
+		switch (node.type) {
+			case NODE_TYPES.BUS_CREATOR:
+				return node.inputs.flatMap((_, i) => resolveIn(level, node.id, i));
+			case NODE_TYPES.BUS_SELECTOR: {
+				const path = selectedSignals(node)[port];
+				const all = resolveIn(level, node.id, 0);
+				const leaves = signalLeaves(structureIn(level, node.id, 0));
+				const picked = path
+					? leaves.flatMap((leaf, i) => (leaf === path || leaf.startsWith(path + SEPARATOR) ? [all[i] ?? null] : []))
+					: [];
+				return picked.length > 0 ? picked : [null];
+			}
+			case NODE_TYPES.SUBSYSTEM:
+				return range(node.id, offsets(level, node, 'out')[port] ?? port, count(structureOut(level, node.id, port)));
+			case NODE_TYPES.INTERFACE: {
+				if (!level.parent) return [{ nodeId, port }];
+				const { level: outer, subsystem } = level.parent;
+				return range(node.id, offsets(outer, subsystem, 'in')[port] ?? port, count(structureIn(outer, subsystem.id, port)));
+			}
+			default:
+				return [{ nodeId, port }];
+		}
+	}
+
+	/** Expanded input slots a connection into a port lands on; bus blocks take none */
+	function inputSlots(level: BusLevel, node: NodeInstance, port: number): Endpoint[] {
+		switch (node.type) {
+			case NODE_TYPES.BUS_CREATOR:
+			case NODE_TYPES.BUS_SELECTOR:
+				return [];
+			case NODE_TYPES.SUBSYSTEM:
+				return range(node.id, offsets(level, node, 'in')[port] ?? port, count(structureIn(level, node.id, port)));
+			case NODE_TYPES.INTERFACE: {
+				if (!level.parent) return [{ nodeId: node.id, port }];
+				const { level: outer, subsystem } = level.parent;
+				return range(node.id, offsets(outer, subsystem, 'out')[port] ?? port, count(structureOut(outer, subsystem.id, port)));
+			}
+			default:
+				return [{ nodeId: node.id, port }];
+		}
+	}
+
+	function expandLevel(level: BusLevel): { nodes: NodeInstance[]; connections: Connection[] } {
+		const expandedNodes: NodeInstance[] = [];
+		for (const node of level.nodeList) {
+			if (isBusBlock(node)) continue;
+			const inner = level.children.get(node.id);
+			if (inner && node.graph) {
+				const expanded = expandLevel(inner);
+				expandedNodes.push({ ...node, graph: { ...node.graph, nodes: expanded.nodes, connections: expanded.connections } });
+			} else {
+				expandedNodes.push(node);
+			}
+		}
+
+		const expandedConnections: Connection[] = [];
+		for (const connection of level.connections) {
+			const target = level.nodes.get(connection.targetNodeId);
+			if (!target || !level.nodes.has(connection.sourceNodeId)) {
+				expandedConnections.push(connection);
+				continue;
+			}
+			const targets = inputSlots(level, target, connection.targetPortIndex);
+			if (targets.length === 0) continue;
+			const sources = resolveOut(level, connection.sourceNodeId, connection.sourcePortIndex);
+			if (sources.length !== targets.length) continue;
+			sources.forEach((source, i) => {
+				const slot = targets[i];
+				if (!source || !slot) return;
+				expandedConnections.push({
+					...connection,
+					id: sources.length === 1 ? connection.id : `${connection.id}${SEPARATOR}${i}`,
+					sourceNodeId: source.nodeId,
+					sourcePortIndex: source.port,
+					targetNodeId: slot.nodeId,
+					targetPortIndex: slot.port
+				});
+			});
+		}
+		return { nodes: expandedNodes, connections: expandedConnections };
+	}
+
+	return expandLevel(root);
+}
diff --git a/src/lib/bus/rename.test.ts b/src/lib/bus/rename.test.ts
new file mode 100644
index 00000000..0a9e844a
--- /dev/null
+++ b/src/lib/bus/rename.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import type { Connection, NodeInstance } from '$lib/types/nodes';
+import fixtures from '../../../tests/fixtures/bus_expansion.json';
+import { renamedSignals, selectorUses } from './rename';
+
+function load(name: string) {
+	const scenario = fixtures.scenarios.find((s) => s.name === name)!;
+	return {
+		nodes: scenario.nodes as unknown as NodeInstance[],
+		connections: scenario.connections as unknown as Connection[]
+	};
+}
+
+const relabel = (connections: Connection[], id: string, label: string) =>
+	connections.map((c) => (c.id === id ? { ...c, label } : c));
+
+describe('bus signal renames', () => {
+	it('finds a selector inside a subsystem and follows the rename', () => {
+		const { nodes, connections } = load('bus into a subsystem');
+		const source = { path: [], creatorId: 'C', input: 1 };
+		const uses = selectorUses(nodes, connections, source);
+		expect(uses).toEqual([{ path: ['Sub'], selectorId: 'Sel', output: 0, signal: 'b', segment: 0 }]);
+		expect(renamedSignals(nodes, relabel(connections, 'c2', 'beta'), source, uses).map((u) => u.signal)).toEqual(['beta']);
+	});
+
+	it('renames a name inside a nested signal path', () => {
+		const { nodes, connections } = load('nested buses and selecting a sub-bus');
+		const source = { path: [], creatorId: 'C1', input: 1 };
+		const uses = selectorUses(nodes, connections, source);
+		expect(uses.map((u) => `${u.selectorId}:${u.output}:${u.signal}`)).toEqual(['S:0:inner.b']);
+		expect(renamedSignals(nodes, relabel(connections, 'c2', 'beta'), source, uses).map((u) => u.signal)).toEqual([
+			'inner.beta'
+		]);
+	});
+
+	it('ignores signals bundled at other inputs', () => {
+		const { nodes, connections } = load('flat creator and selector');
+		expect(selectorUses(nodes, connections, { path: [], creatorId: 'C', input: 1 }).map((u) => u.output)).toEqual([0]);
+		expect(selectorUses(nodes, connections, { path: [], creatorId: 'other', input: 0 })).toEqual([]);
+	});
+});
diff --git a/src/lib/bus/rename.ts b/src/lib/bus/rename.ts
new file mode 100644
index 00000000..ce9d5270
--- /dev/null
+++ b/src/lib/bus/rename.ts
@@ -0,0 +1,90 @@
+/**
+ * Bus signal renames - Bus Selector outputs that pick a signal named at a Bus
+ * Creator input, found through nested buses and subsystems, and their picked
+ * signal paths after the rename
+ */
+
+import type { Connection, NodeInstance } from '$lib/types/nodes';
+import { NODE_TYPES } from '$lib/constants/nodeTypes';
+import {
+	analyzeBuses,
+	levelPath,
+	selectedSignals,
+	SIGNAL_SEPARATOR,
+	type BusLevel,
+	type BusStructure
+} from './expand';
+
+/** A Bus Creator input, located by the subsystem path of its level */
+export interface CreatorInput {
+	path: string[];
+	creatorId: string;
+	input: number;
+}
+
+/** A Bus Selector output picking a signal that runs through a creator input */
+export interface SelectorUse {
+	path: string[];
+	selectorId: string;
+	output: number;
+	signal: string;
+	/** Index of the name in the signal path that the creator input names */
+	segment: number;
+}
+
+function* levels(level: BusLevel): Generator<BusLevel> {
+	yield level;
+	for (const child of level.children.values()) yield* levels(child);
+}
+
+/** Index of the path name bundled at the creator input, or -1 if the path does not run through it */
+function segmentThrough(structure: BusStructure, signal: string, source: CreatorInput): number {
+	let elements = structure;
+	const names = signal.split(SIGNAL_SEPARATOR);
+	for (let i = 0; i < names.length; i++) {
+		const element = elements?.find((e) => e.name === names[i]);
+		if (!element) return -1;
+		if (element.origin?.creatorId === source.creatorId && element.origin.input === source.input) return i;
+		elements = element.structure;
+	}
+	return -1;
+}
+
+/** Selector outputs anywhere in the model whose picked signal runs through the creator input */
+export function selectorUses(nodes: NodeInstance[], connections: Connection[], source: CreatorInput): SelectorUse[] {
+	const analysis = analyzeBuses(nodes, connections);
+	const uses: SelectorUse[] = [];
+	for (const level of levels(analysis.root)) {
+		for (const node of level.nodeList) {
+			if (node.type !== NODE_TYPES.BUS_SELECTOR) continue;
+			const structure = analysis.structureIn(level, node.id, 0);
+			selectedSignals(node).forEach((signal, output) => {
+				const segment = segmentThrough(structure, signal, source);
+				if (segment >= 0) uses.push({ path: levelPath(level), selectorId: node.id, output, signal, segment });
+			});
+		}
+	}
+	return uses;
+}
+
+/**
+ * The uses with their signal paths following the renamed creator input.
+ * `nodes` and `connections` are the model after the rename.
+ */
+export function renamedSignals(
+	nodes: NodeInstance[],
+	connections: Connection[],
+	source: CreatorInput,
+	uses: SelectorUse[]
+): SelectorUse[] {
+	const analysis = analyzeBuses(nodes, connections);
+	const level = analysis.levelAt(source.path);
+	const creator = level?.nodes.get(source.creatorId);
+	if (!level || !creator) return [];
+	const name = analysis.elementNames(level, creator)[source.input];
+	return uses.map((use) => {
+		const names = use.signal.split(SIGNAL_SEPARATOR);
+		names[use.segment] = name;
+		return { ...use, signal: names.join(SIGNAL_SEPARATOR) };
+	});
+}
diff --git a/src/lib/components/FlowCanvas.svelte b/src/lib/components/FlowCanvas.svelte
index 5d3be6e8..bf6f5dd1 100644
--- a/src/lib/components/FlowCanvas.svelte
+++ b/src/lib/components/FlowCanvas.svelte
@@ -38,6 +38,9 @@
 	import { NODE_TYPES } from '$lib/constants/nodeTypes';
 	import { GRID_SIZE, SNAP_GRID, BACKGROUND_GAP } from '$lib/constants/grid';
 	import { createRoutingSync } from './canvas/routingSync';
+	import { isBusBlock } from '$lib/bus/expand';
+	import { updateBusView } from '$lib/stores/busView.svelte';
+	import BusBlockNode from './nodes/BusBlockNode.svelte';
 	import { createEdgeHighlighter } from '$lib/stores/edgeHighlight';
 	import { CANVAS_MIN_ZOOM } from '$lib/constants/layout';
 	import { shallowEqualArray, shallowEqualRecord } from '$lib/utils/shallowEqual';
@@ -49,6 +52,7 @@
 		toFlowEdge,
 		toEventNode,
 		toAnnotationNode,
+		isBlockFlowNode,
 		rotateSelectedNodes,
 		flipSelectedNodesHorizontal,
 		flipSelectedNodesVertical,
@@ -271,7 +275,7 @@
 
 	// Routing: the scene is diffed here and routed by the routing engine in a worker
 	const routingSync = createRoutingSync({
-		blockNodes: () => nodes.filter((n) => n.type === 'pathview'),
+		blockNodes: () => nodes.filter(isBlockFlowNode),
 		node: (id) => nodeMap.get(id),
 		connections: () => get(graphStore.connections),
 		visibleBounds
@@ -289,6 +293,7 @@
 	// Custom node types - will add more for different shapes
 	const nodeTypes: NodeTypes = {
 		pathview: BaseNode,
+		busBlock: BusBlockNode,
 		eventNode: EventNode,
 		annotation: AnnotationNode
 	};
@@ -334,7 +339,7 @@
 	$effect(() => {
 		const changed = new Set<string>();
 		for (const node of nodes) {
-			if (node.type !== 'pathview') continue;
+			if (!isBlockFlowNode(node)) continue;
 			const w = node.measured?.width;
 			const h = node.measured?.height;
 			if (w === undefined || h === undefined) continue;
@@ -512,7 +517,7 @@
 			// New node
 			return {
 				id: graphNode.id,
-				type: 'pathview',
+				type: isBusBlock(graphNode) ? 'busBlock' : 'pathview',
 				position,
 				data: graphNode,
 				// Explicit center origin for correct bounds calculation
@@ -605,6 +610,8 @@
 	function rebuildEdges(connections: Connection[]): void {
 		const visibleIds = getVisibleNodeIds();
 		const currentEdgeSelection = new Map(edges.map((e) => [e.id, e.selected]));
+		// Bus wires and bus block signal names follow the same graph changes as the edges
+		updateBusView(graphStore.toJSON(), graphStore.getCurrentPath(), connections);
 		edges = connections
 			.filter((c) => visibleIds.has(c.sourceNodeId) && visibleIds.has(c.targetNodeId))
 			.map((conn) => {
@@ -653,7 +660,7 @@
 		const moved: string[] = [];
 		for (const node of draggedNodes) {
 			// Events and annotations don't affect routing
-			if (node.type !== 'pathview') continue;
+			if (!isBlockFlowNode(node)) continue;
 
 			const snapped = {
 				x: Math.round(node.position.x / GRID_SIZE) * GRID_SIZE,
@@ -766,9 +773,7 @@
 		annotationNodes = annotationNodes.filter(n => !deletedIds.has(n.id));
 
 		// Force sync edges from store after deletion
-		const afterConnections = get(graphStore.connections);
-		edges = afterConnections.map(toFlowEdge);
-		edgeHighlighter.refresh();
+		rebuildEdges(get(graphStore.connections));
 
 		isSyncing = false;
 	}
@@ -1046,10 +1051,10 @@
 		fill: var(--grid-dot);
 	}
 
-	/* Edge styling */
+	/* Edge styling; --wire-scale thickens a wire in every state, e.g. for buses */
 	:global(.svelte-flow__edge-path) {
 		stroke: var(--edge);
-		stroke-width: 1;
+		stroke-width: calc(1px * var(--wire-scale, 1));
 		transition: stroke 0.15s ease;
 		cursor: pointer;
 	}
@@ -1063,12 +1068,12 @@
 
 	:global(.svelte-flow__edge:hover .svelte-flow__edge-path) {
 		stroke: var(--accent, #0070C0);
-		stroke-width: 1;
+		stroke-width: calc(1px * var(--wire-scale, 1));
 	}
 
 	:global(.svelte-flow__edge.selected .svelte-flow__edge-path) {
 		stroke: var(--accent, #0070C0);
-		stroke-width: 1.5;
+		stroke-width: calc(1.5px * var(--wire-scale, 1));
 	}
 
 	/* Connection line */
diff --git a/src/lib/components/InlineInput.svelte b/src/lib/components/InlineInput.svelte
new file mode 100644
index 00000000..363a89a4
--- /dev/null
+++ b/src/lib/components/InlineInput.svelte
@@ -0,0 +1,213 @@
+<script lang="ts">
+	import { INLINE_INPUT } from '$lib/constants/dimensions';
+
+	interface Props {
+		value?: string;
+		placeholder?: string;
+		/** Names offered below the input; omit for a plain text field */
+		suggestions?: string[];
+		onCommit: (text: string) => void;
+		onCancel: () => void;
+	}
+
+	let { value = '', placeholder = '', suggestions, onCommit, onCancel }: Props = $props();
+
+	interface Option {
+		text: string;
+		/** Index of the query inside the text */
+		match: number;
+	}
+
+	// svelte-ignore state_referenced_locally
+	let text = $state(value);
+	let activeIndex = $state(0);
+	// Until the user types, the initial text does not filter and all suggestions are offered
+	let touched = $state(false);
+	let listPosition = $state<{ x: number; y: number } | null>(null);
+	let listEl = $state<HTMLElement | null>(null);
+
+	const query = $derived(touched ? text.trim() : '');
+
+	// Matching suggestions, prefix matches first
+	const options = $derived.by((): Option[] => {
+		if (!suggestions) return [];
+		const lower = query.toLowerCase();
+		return suggestions
+			.map((name) => ({ text: name, match: name.toLowerCase().indexOf(lower) }))
+			.filter((option) => option.match >= 0)
+			.sort((a, b) => a.match - b.match)
+			.slice(0, INLINE_INPUT.maxSuggestions);
+	});
+
+	const active = $derived(Math.min(activeIndex, options.length - 1));
+
+	function commitActive() {
+		onCommit(active >= 0 ? options[active].text : text);
+	}
+
+	function pick(event: PointerEvent, option: Option) {
+		event.preventDefault();
+		event.stopPropagation();
+		onCommit(option.text);
+	}
+
+	/**
+	 * Enter commits, Escape cancels, a pointer press outside commits the typed
+	 * text. Blur alone never commits, because removing the editor also blurs
+	 * the input. Keys stop at the input so canvas shortcuts never see them.
+	 * Focus waits a frame, the caller may still move the input into a portal.
+	 * While suggestions are shown, the list follows the input on screen.
+	 */
+	function inlineInput(input: HTMLInputElement) {
+		const onKeydown = (event: KeyboardEvent) => {
+			event.stopPropagation();
+			const count = options.length;
+			if (event.key === 'Enter') commitActive();
+			else if (event.key === 'Escape') onCancel();
+			else if (event.key === 'ArrowDown' && count > 0) {
+				event.preventDefault();
+				activeIndex = (active + 1) % count;
+			} else if (event.key === 'ArrowUp' && count > 0) {
+				event.preventDefault();
+				activeIndex = (active - 1 + count) % count;
+			} else if (event.key === 'Tab' && active >= 0) {
+				event.preventDefault();
+				text = options[active].text;
+			}
+		};
+		const onInput = () => {
+			touched = true;
+			activeIndex = 0;
+		};
+		const onPointerDown = (event: PointerEvent) => {
+			const target = event.target as Node;
+			if (target !== input && !listEl?.contains(target)) onCommit(text);
+		};
+
+		let frame = 0;
+		const follow = () => {
+			const rect = input.getBoundingClientRect();
+			const x = rect.left + rect.width / 2;
+			const y = rect.bottom + INLINE_INPUT.listGap;
+			if (listPosition?.x !== x || listPosition?.y !== y) listPosition = { x, y };
+			frame = requestAnimationFrame(follow);
+		};
+
+		input.addEventListener('keydown', onKeydown);
+		input.addEventListener('input', onInput);
+		document.addEventListener('pointerdown', onPointerDown, true);
+		requestAnimationFrame(() => {
+			input.focus();
+			input.select();
+			if (suggestions) follow();
+		});
+		return {
+			destroy: () => {
+				cancelAnimationFrame(frame);
+				input.removeEventListener('keydown', onKeydown);
+				input.removeEventListener('input', onInput);
+				document.removeEventListener('pointerdown', onPointerDown, true);
+			}
+		};
+	}
+
+	/** Render at the document root, so the list keeps screen size and is never clipped by the canvas */
+	function portal(node: HTMLElement) {
+		document.body.appendChild(node);
+		return { destroy: () => node.remove() };
+	}
+</script>
+
+<input
+	class="inline-input"
+	style="--input-height: {INLINE_INPUT.height}px; --input-padding-x: {INLINE_INPUT.paddingX}px; --input-chars: {Math.max(text.length, INLINE_INPUT.minChars)};"
+	bind:value={text}
+	{placeholder}
+	use:inlineInput
+/>
+
+{#if options.length > 0 && listPosition}
+	<div
+		bind:this={listEl}
+		class="inline-input-list"
+		style="left: {listPosition.x}px; top: {listPosition.y}px;"
+		role="listbox"
+		use:portal
+	>
+		{#each options as option, i (option.text)}
+			<div
+				class="option"
+				class:active={i === active}
+				role="option"
+				aria-selected={i === active}
+				tabindex="-1"
+				onpointerdown={(event) => pick(event, option)}
+				onpointerenter={() => (activeIndex = i)}
+			>
+				{#if query}
+					{option.text.slice(0, option.match)}<span class="hit"
+						>{option.text.slice(option.match, option.match + query.length)}</span
+					>{option.text.slice(option.match + query.length)}
+				{:else}
+					{option.text}
+				{/if}
+			</div>
+		{/each}
+	</div>
+{/if}
+
+<style>
+	/* Capsule on the canvas, styled like an active waypoint */
+	.inline-input {
+		box-sizing: border-box;
+		height: var(--input-height);
+		width: calc(var(--input-chars) * 1ch + 2 * var(--input-padding-x));
+		padding: 0 var(--input-padding-x);
+		border: 1.5px solid var(--accent);
+		border-radius: calc(var(--input-height) / 2);
+		background: var(--surface);
+		color: var(--text);
+		font-family: var(--font-ui);
+		font-size: var(--font-xs);
+		text-align: center;
+		outline: none;
+	}
+
+	.inline-input::placeholder {
+		color: var(--text-muted);
+	}
+
+	/* Suggestion list in screen space, styled like the context menu */
+	.inline-input-list {
+		position: fixed;
+		z-index: var(--z-dropdown);
+		transform: translateX(-50%);
+		min-width: 100px;
+		padding: 2px;
+		display: flex;
+		flex-direction: column;
+		gap: 1px;
+		background: var(--surface);
+		border: 1px solid var(--border);
+		border-radius: var(--radius-sm);
+		box-shadow: var(--shadow-md);
+	}
+
+	.option {
+		padding: 3px 8px;
+		border-radius: 4px;
+		font-family: var(--font-ui);
+		font-size: var(--font-base);
+		color: var(--text-muted);
+		white-space: nowrap;
+		cursor: pointer;
+	}
+
+	.option.active {
+		background: var(--accent-bg);
+	}
+
+	.hit {
+		color: var(--text);
+		font-weight: 500;
+	}</style>
diff --git a/src/lib/components/canvas/flowConverters.ts b/src/lib/components/canvas/flowConverters.ts
index 712ebc09..3ec09dea 100644
--- a/src/lib/components/canvas/flowConverters.ts
+++ b/src/lib/components/canvas/flowConverters.ts
@@ -7,6 +7,14 @@ import type { Connection, Annotation } from '$lib/nodes/types';
 import type { EventInstance } from '$lib/events/types';
 import { HANDLE_ID } from '$lib/constants/handles';
 
+/** Canvas node types that are blocks with ports: regular blocks and bus blocks */
+const BLOCK_NODE_TYPES = new Set(['pathview', 'busBlock']);
+
+/** Whether a canvas node is a block with ports, as opposed to an event or annotation */
+export function isBlockFlowNode(node: Node): boolean {
+	return BLOCK_NODE_TYPES.has(node.type ?? '');
+}
+
 /**
  * Convert an EventInstance to a SvelteFlow Node
  */
diff --git a/src/lib/components/canvas/routingSync.ts b/src/lib/components/canvas/routingSync.ts
index 0fb676ea..3d71ae6b 100644
--- a/src/lib/components/canvas/routingSync.ts
+++ b/src/lib/components/canvas/routingSync.ts
@@ -13,6 +13,7 @@ import type { Bounds, PortInfo, PortStub, RouteRequest, SceneNode } from '$lib/r
 import { getPortInfo } from '$lib/routing';
 import { DEFAULT_NODE_WIDTH, DEFAULT_NODE_HEIGHT } from '$lib/constants/dimensions';
 import { routingStore } from '$lib/stores/routing';
+import { isBlockFlowNode } from './flowConverters';
 
 export interface RoutingSyncSource {
 	/** Block nodes currently shown on the canvas */
@@ -147,7 +148,7 @@ export function createRoutingSync(source: RoutingSyncSource) {
 			const entries: [string, SceneNode][] = [];
 			for (const id of ids) {
 				const node = source.node(id);
-				if (node?.type === 'pathview') entries.push([id, sceneNodeOf(node, positions?.get(id))]);
+				if (node && isBlockFlowNode(node)) entries.push([id, sceneNodeOf(node, positions?.get(id))]);
 			}
 			const { changed } = routingStore.diffNodes(entries, false);
 			if (changed.length === 0) return;
diff --git a/src/lib/components/contextMenuBuilders.ts b/src/lib/components/contextMenuBuilders.ts
index e1be1ef6..656797b2 100644
--- a/src/lib/components/contextMenuBuilders.ts
+++ b/src/lib/components/contextMenuBuilders.ts
@@ -9,7 +9,7 @@ import type { ContextMenuTarget } from '$lib/stores/contextMenu';
 import { graphStore, ANNOTATION_FONT_SIZE } from '$lib/stores/graph';
 import { historyStore } from '$lib/stores/history';
 import { routingStore } from '$lib/stores/routing';
-import { editEdgeLabel } from '$lib/stores/edgeLabelEdit.svelte';
+import { editInline } from '$lib/stores/inlineEdit.svelte';
 import { eventStore } from '$lib/stores/events';
 import { clipboardStore } from '$lib/stores/clipboard';
 import { codePreviewStore } from '$lib/stores/codePreview';
@@ -404,7 +404,7 @@ function buildEdgeMenu(edgeId: string): MenuItemType[] {
 		{
 			label: 'Edit Label',
 			icon: 'tag',
-			action: () => editEdgeLabel(edgeId)
+			action: () => editInline(edgeId)
 		},
 		{
 			label: 'Reset Route',
diff --git a/src/lib/components/dialogs/BlockPropertiesDialog.svelte b/src/lib/components/dialogs/BlockPropertiesDialog.svelte
index ebff1051..c9e3e1d3 100644
--- a/src/lib/components/dialogs/BlockPropertiesDialog.svelte
+++ b/src/lib/components/dialogs/BlockPropertiesDialog.svelte
@@ -23,6 +23,7 @@
 	import { createRecordingDataState } from '$lib/stores/recordingData.svelte';
 	import { getPortLabelConfigs } from '$lib/nodes/uiConfig';
 	import { PORT_NAME } from '$lib/constants/handles';
+	import { analyzeBuses, selectedSignals, signalPaths } from '$lib/bus/expand';
 
 	// Code preview state (declared early — referenced by subscription below)
 	let showCode = $state(false);
@@ -93,6 +94,33 @@
 	// Get current color for display
 	const currentColor = $derived(node?.color || DEFAULT_NODE_COLOR);
 
+	// Bus Selector: signals on the bus at its input, and the ones it picks
+	const isBusSelector = $derived(node?.type === NODE_TYPES.BUS_SELECTOR);
+	const busSignalOptions = $derived.by(() => {
+		if (!node || node.type !== NODE_TYPES.BUS_SELECTOR) return [];
+		const model = graphStore.toJSON();
+		const analysis = analyzeBuses(model.nodes, model.connections);
+		const level = analysis.levelAt(graphStore.getCurrentPath());
+		return level ? signalPaths(analysis.structureIn(level, node.id, 0)) : [];
+	});
+	const pickedSignals = $derived(node ? selectedSignals(node) : []);
+	// Picked signals the bus no longer carries stay listed until they are unpicked
+	const missingSignals = $derived(pickedSignals.filter((s) => !busSignalOptions.some((o) => o.path === s)));
+
+	function toggleSignal(path: string, picked: boolean) {
+		if (!node) return;
+		const id = node.id;
+		const chosen = new Set(pickedSignals);
+		if (picked) chosen.add(path);
+		else chosen.delete(path);
+		// Outputs keep the order of the bus
+		const ordered = [
+			...busSignalOptions.map((o) => o.path).filter((p) => chosen.has(p)),
+			...missingSignals.filter((p) => chosen.has(p))
+		];
+		historyStore.mutate(() => graphStore.setSelectedSignals(id, ordered));
+	}
+
 	// Handle color selection
 	function handleColorSelect(color: string | undefined) {
 		if (!node) return;
@@ -440,7 +468,33 @@
 					{/if}
 				{:else}
 					<!-- Parameters -->
-					{#if typeDef.params.length > 0}
+					{#if isBusSelector}
+						<div class="section">
+							<div class="section-title">Signals</div>
+							{#if busSignalOptions.length === 0 && missingSignals.length === 0}
+								<div class="no-params">Connect a bus to the input to pick signals</div>
+							{:else}
+								<div class="signal-list">
+									{#each busSignalOptions as option (option.path)}
+										<label class="signal-item" style="--signal-depth: {option.depth};">
+											<input
+												type="checkbox"
+												checked={pickedSignals.includes(option.path)}
+												onchange={(e) => toggleSignal(option.path, e.currentTarget.checked)}
+											/>
+											<span class:bus-signal={option.isBus}>{option.path.split('.').pop()}</span>
+										</label>
+									{/each}
+									{#each missingSignals as path (path)}
+										<label class="signal-item missing" use:tooltip={'No longer on the bus'}>
+											<input type="checkbox" checked onchange={(e) => toggleSignal(path, e.currentTarget.checked)} />
+											<span>{path}</span>
+										</label>
+									{/each}
+								</div>
+							{/if}
+						</div>
+					{:else if typeDef.params.length > 0}
 						<div class="section">
 							<div class="section-title">Parameters</div>
 							<div class="params-grid">
diff --git a/src/lib/components/edges/OrthogonalEdge.svelte b/src/lib/components/edges/OrthogonalEdge.svelte
index c5c5c485..589e3229 100644
--- a/src/lib/components/edges/OrthogonalEdge.svelte
+++ b/src/lib/components/edges/OrthogonalEdge.svelte
@@ -30,11 +30,13 @@
 	import { routingStore } from '$lib/stores/routing';
 	import { graphStore } from '$lib/stores/graph';
 	import { edgeHighlights } from '$lib/stores/edgeHighlight';
-	import { edgeLabelEdit, editEdgeLabel } from '$lib/stores/edgeLabelEdit.svelte';
+	import { inlineEdit, editInline } from '$lib/stores/inlineEdit.svelte';
 	import { historyStore } from '$lib/stores/history';
 	import { screenToFlow } from '$lib/utils/viewUtils';
 	import { GRID_SIZE, EDGE_SOURCE_OFFSET, EDGE_TARGET_OFFSET, EDGE_CORNER_RADIUS } from '$lib/routing/constants';
-	import { EDGE_LABEL } from '$lib/constants/dimensions';
+	import InlineInput from '$lib/components/InlineInput.svelte';
+	import { BUS } from '$lib/constants/dimensions';
+	import { busWires, busCreatorWires } from '$lib/stores/busView.svelte';
 	import type { Direction, RouteResult } from '$lib/routing';
 	import type { Waypoint } from '$lib/types/nodes';
 
@@ -61,6 +63,12 @@
 		[Position.Bottom]: -90
 	};
 
+	/** Arrowhead with its tip at the origin, pointing along +x */
+	const ARROW_PATH = 'M -5 -2.5 L -1 -0.5 Q 0 0 -1 0.5 L -5 2.5 Q -6 3 -6 2 L -6 -2 Q -6 -3 -5 -2.5 Z';
+
+	/** Wider arrowhead for the thicker bus wire; its base overlaps the wire end */
+	const BUS_ARROW_PATH = 'M -5.5 -3 L -1 -0.5 Q 0 0 -1 0.5 L -5.5 3 Q -6.5 3.5 -6.5 2.5 L -6.5 -2.5 Q -6.5 -3.5 -5.5 -3 Z';
+
 	/** Minimum distance of a segment midpoint handle from an existing waypoint */
 	const MIN_DISTANCE_FROM_WAYPOINT = 20;
 
@@ -190,7 +198,13 @@
 	}
 
 	// Path ends at the handle tips: small inset at the source, room for the arrowhead at the target
-	const adjustedSource = $derived(alongFacing(sourceX, sourceY, sourcePosition, -EDGE_SOURCE_OFFSET));
+	// Wires carrying a bus are drawn thicker
+	const carriesBus = $derived(busWires.has(id));
+
+	// A bus wire starts inside the solid bus port, so the thick line joins it without a gap
+	const adjustedSource = $derived(
+		alongFacing(sourceX, sourceY, sourcePosition, -(carriesBus ? BUS.sourceInset : EDGE_SOURCE_OFFSET))
+	);
 	const adjustedTarget = $derived(alongFacing(targetX, targetY, targetPosition, EDGE_TARGET_OFFSET));
 
 	/**
@@ -298,78 +312,47 @@
 		return midpoints;
 	});
 
+
 	// Connection label, shown on the middle of the longest route segment
 	const label = $derived((data as { label?: string } | undefined)?.label ?? '');
-	const isEditingLabel = $derived(edgeLabelEdit.connectionId === id);
-
-	// Editor width follows the typed text
-	let draftLength = $state(0);
+	const isEditingLabel = $derived(inlineEdit.targetId === id);
 
-	const labelAnchor = $derived.by(() => {
+	// Middle of the longest route segment, where the label sits
+	const segmentAnchor = $derived.by(() => {
 		if (!label && !isEditingLabel) return null;
 		const points = displayedRoute
 			? [adjustedSource, ...displayedRoute.path, adjustedTarget]
 			: [adjustedSource, adjustedTarget];
-		let anchor = points[0];
+		let anchor = { ...points[0], vertical: false };
 		let longest = -1;
 		for (let i = 0; i < points.length - 1; i++) {
-			const length = Math.abs(points[i + 1].x - points[i].x) + Math.abs(points[i + 1].y - points[i].y);
-			if (length > longest) {
-				longest = length;
-				anchor = { x: (points[i].x + points[i + 1].x) / 2, y: (points[i].y + points[i + 1].y) / 2 };
+			const dx = Math.abs(points[i + 1].x - points[i].x);
+			const dy = Math.abs(points[i + 1].y - points[i].y);
+			if (dx + dy > longest) {
+				longest = dx + dy;
+				anchor = {
+					x: (points[i].x + points[i + 1].x) / 2,
+					y: (points[i].y + points[i + 1].y) / 2,
+					vertical: dy > dx
+				};
 			}
 		}
 		return anchor;
 	});
+	const labelAnchor = $derived(label || isEditingLabel ? segmentAnchor : null);
 
 	function handleEdgeDoubleClick(event: MouseEvent) {
 		event.stopPropagation();
-		editEdgeLabel(id);
+		editInline(id);
 	}
 
 	function commitLabel(text: string) {
-		if (edgeLabelEdit.connectionId !== id) return;
-		editEdgeLabel(null);
+		if (inlineEdit.targetId !== id) return;
+		editInline(null);
 		if (text.trim() === label) return;
 		historyStore.mutate(() => graphStore.updateConnectionLabel(id, text));
 	}
 
-	/**
-	 * Label editor input. Enter commits, Escape cancels, a pointer press outside
-	 * the input commits. Blur alone never commits, because removing the editor
-	 * also blurs the input. Keys are stopped at the input so edge keyboard
-	 * handling and app shortcuts never see them. Focus waits until the input
-	 * sits in the label layer.
-	 */
-	function labelEditor(input: HTMLInputElement) {
-		const onKeydown = (event: KeyboardEvent) => {
-			event.stopPropagation();
-			if (event.key === 'Enter') commitLabel(input.value);
-			else if (event.key === 'Escape') editEdgeLabel(null);
-		};
-		const onPointerDown = (event: PointerEvent) => {
-			if (event.target !== input) commitLabel(input.value);
-		};
-		const onInput = () => {
-			draftLength = input.value.length;
-		};
-		draftLength = input.value.length;
-		input.addEventListener('keydown', onKeydown);
-		input.addEventListener('input', onInput);
-		document.addEventListener('pointerdown', onPointerDown, true);
-		requestAnimationFrame(() => {
-			input.focus();
-			input.select();
-		});
-		return {
-			destroy: () => {
-				input.removeEventListener('keydown', onKeydown);
-				input.removeEventListener('input', onInput);
-				document.removeEventListener('pointerdown', onPointerDown, true);
-			}
-		};
-	}
-
 	// Segment drag creates a waypoint, then drags it
 	function handleSegmentPointerDown(event: PointerEvent, segmentIndex: number) {
 		event.stopPropagation();
@@ -419,7 +402,8 @@
 <!-- svelte-ignore a11y_no_static_element_interactions -->
 <g
 	class:highlighted={highlightColor !== undefined}
-	style={highlightColor !== undefined ? `--highlight-color: ${highlightColor}` : undefined}
+	class:bus-wire={carriesBus}
+	style="{carriesBus ? `--wire-scale: ${BUS.wireScale};` : ''}{highlightColor !== undefined ? ` --highlight-color: ${highlightColor};` : ''}"
 	ondblclick={handleEdgeDoubleClick}
 >
 	<BaseEdge {id} {path} {style} />
@@ -457,17 +441,19 @@
 	<!-- Arrow at the end - offset forward 5px to reach target handle tip -->
 	<g transform="translate({endArrow.x}, {endArrow.y}) rotate({endArrow.angle}) translate(5, 0)">
 		<path
-			d="M -5 -2.5 L -1 -0.5 Q 0 0 -1 0.5 L -5 2.5 Q -6 3 -6 2 L -6 -2 Q -6 -3 -5 -2.5 Z"
+			d={carriesBus ? BUS_ARROW_PATH : ARROW_PATH}
 			class="edge-arrow"
 			class:selected
 			class:highlighted={highlightColor !== undefined}
 		/>
 	</g>
 
-	{#if label && !isEditingLabel && labelAnchor}
+	<!-- Labels on vertical segments read bottom to top along the wire; a wire into a Bus Creator shows its label at the creator port -->
+	{#if label && !isEditingLabel && labelAnchor && !busCreatorWires.has(id)}
 		<text
 			x={labelAnchor.x}
 			y={labelAnchor.y}
+			transform={labelAnchor.vertical ? `rotate(-90 ${labelAnchor.x} ${labelAnchor.y})` : undefined}
 			class="edge-label"
 			class:selected
 			class:highlighted={highlightColor !== undefined}>{label}</text
@@ -477,13 +463,7 @@
 
 {#if isEditingLabel && labelAnchor}
 	<EdgeLabel x={labelAnchor.x} y={labelAnchor.y} transparent>
-		<input
-			class="edge-label-input"
-			style="--label-height: {EDGE_LABEL.height}px; --label-padding-x: {EDGE_LABEL.paddingX}px; --label-chars: {Math.max(draftLength, EDGE_LABEL.minChars)};"
-			value={label}
-			placeholder="Label"
-			use:labelEditor
-		/>
+		<InlineInput value={label} placeholder="Label" onCommit={commitLabel} onCancel={() => editInline(null)} />
 	</EdgeLabel>
 {/if}
 
@@ -539,26 +519,6 @@
 		fill: var(--highlight-color, var(--accent));
 	}
 
-	/* Inline label editor: same capsule, active like a dragged waypoint */
-	.edge-label-input {
-		box-sizing: border-box;
-		height: var(--label-height);
-		width: calc(var(--label-chars) * 1ch + 2 * var(--label-padding-x));
-		padding: 0 var(--label-padding-x);
-		border: 1.5px solid var(--accent);
-		border-radius: calc(var(--label-height) / 2);
-		background: var(--surface);
-		color: var(--text);
-		font-family: var(--font-ui);
-		font-size: var(--font-xs);
-		text-align: center;
-		outline: none;
-	}
-
-	.edge-label-input::placeholder {
-		color: var(--text-muted);
-	}
-
 	/* Waypoint group - visibility controlled by inline styles */
 	.waypoint-group {
 		transition: opacity 0.1s ease;
diff --git a/src/lib/components/nodes/BaseNode.svelte b/src/lib/components/nodes/BaseNode.svelte
index b541d0ca..7ee48d2a 100644
--- a/src/lib/components/nodes/BaseNode.svelte
+++ b/src/lib/components/nodes/BaseNode.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
 	import { onDestroy } from 'svelte';
-	import { Handle, Position, useUpdateNodeInternals } from '@xyflow/svelte';
+	import { useUpdateNodeInternals } from '@xyflow/svelte';
 	import { nodeRegistry, registryVersion, type NodeInstance } from '$lib/nodes';
 	import { getShapeCssClass, isSubsystem } from '$lib/nodes/shapes/index';
 	import { NODE_TYPES } from '$lib/constants/nodeTypes';
@@ -12,15 +12,15 @@
 	import { iconModeStore } from '$lib/stores/iconMode';
 	import BlockIcon, { hasBlockIcon } from '$lib/components/icons/BlockIcon.svelte';
 	import { PREVIEW_GAP, previewSideForRotation } from '$lib/utils/previewBounds';
-	import { hoveredHandle, selectedNodeHighlight } from '$lib/stores/hoveredHandle';
-	import { showTooltip, hideTooltip } from '$lib/components/Tooltip.svelte';
+	import { selectedNodeHighlight } from '$lib/stores/hoveredHandle';
 	import { paramInput } from '$lib/actions/paramInput';
 	import { plotDataStore } from '$lib/plotting/processing/plotDataStore';
-	import { getPortPositionCalc, calculateNodeDimensions } from '$lib/constants/dimensions';
-	import { truncatePortLabel } from '$lib/utils/portLabels';
+	import { calculateNodeDimensions } from '$lib/constants/dimensions';
 	import { containsMath, renderInlineMath, renderInlineMathSync, measureRenderedMath } from '$lib/utils/inlineMathRenderer';
 	import { getKatexCssUrl } from '$lib/utils/katexLoader';
 	import PlotPreview from './PlotPreview.svelte';
+	import NodePorts from './NodePorts.svelte';
+	import { busPorts } from '$lib/stores/busView.svelte';
 
 	interface Props {
 		id: string;
@@ -97,10 +97,6 @@
 	const showInputLabels = $derived(nodeShowInputLabels ?? globalShowPortLabels);
 	const showOutputLabels = $derived(nodeShowOutputLabels ?? globalShowPortLabels);
 
-	// Actual visibility: setting is ON and ports exist (single source of truth)
-	const hasVisibleInputLabels = $derived(showInputLabels && data.inputs.length > 0);
-	const hasVisibleOutputLabels = $derived(showOutputLabels && data.outputs.length > 0);
-
 
 	// Re-measure node when port labels toggle changes
 	$effect(() => {
@@ -197,29 +193,6 @@
 	// Rotation state (0, 1, 2, 3 = 0°, 90°, 180°, 270°) - stored in node params
 	const rotation = $derived((data.params?.['_rotation'] as number) || 0);
 
-	// Calculate actual port positions based on rotation
-	// 0: inputs left, outputs right (default)
-	// 1: inputs top, outputs bottom
-	// 2: inputs right, outputs left
-	// 3: inputs bottom, outputs top
-	const inputPosition = $derived(() => {
-		switch (rotation) {
-			case 1: return Position.Top;
-			case 2: return Position.Right;
-			case 3: return Position.Bottom;
-			default: return Position.Left;
-		}
-	});
-
-	const outputPosition = $derived(() => {
-		switch (rotation) {
-			case 1: return Position.Bottom;
-			case 2: return Position.Left;
-			case 3: return Position.Top;
-			default: return Position.Right;
-		}
-	});
-
 	// Port is horizontal (left/right) or vertical (top/bottom)
 	const isVertical = $derived(rotation === 1 || rotation === 3);
 
@@ -250,46 +223,6 @@
 		showIcon
 	));
 
-	/** Inline style for a port label, positioning it outside the block edge
-	 *  next to its handle. The handle/wire is always *below* the label from
-	 *  the label's perspective — i.e. the anchor point sits at the label's
-	 *  bottom-left or bottom-right corner.
-	 *
-	 *  Horizontal block: text horizontal, label sits just above the wire stub.
-	 *  Vertical block: `writing-mode: sideways-{lr|rl}` rotates the text
-	 *    parallel to the wire (no transform tricks needed for positioning,
-	 *    so the perpendicular offset works in screen-space directly). Top
-	 *    edge reads bottom-to-top, bottom edge top-to-bottom — both read
-	 *    *outward* from the block. */
-	function portLabelStyle(isInput: boolean, portIndex: number, total: number): string {
-		const pos = getPortPositionCalc(portIndex, total);
-		const GAP = 10; // distance from block edge along the wire
-		const PERP = 5; // perpendicular offset off the wire path
-
-		// Map (rotation, isInput) → which block edge hosts the port.
-		let edge: 'left' | 'right' | 'top' | 'bottom';
-		if (rotation === 0) edge = isInput ? 'left' : 'right';
-		else if (rotation === 2) edge = isInput ? 'right' : 'left';
-		else if (rotation === 1) edge = isInput ? 'top' : 'bottom';
-		else edge = isInput ? 'bottom' : 'top';
-
-		switch (edge) {
-			case 'left':
-				// Anchor (port) at label bottom-right.
-				return `right: 100%; margin-right: ${GAP}px; top: ${pos}; transform: translateY(calc(-100% - ${PERP}px)); text-align: right;`;
-			case 'right':
-				// Anchor at label bottom-left.
-				return `left: 100%; margin-left: ${GAP}px; top: ${pos}; transform: translateY(calc(-100% - ${PERP}px)); text-align: left;`;
-			case 'top':
-				// Reads bottom-to-top, label LEFT of wire. Anchor at bottom-right.
-				return `bottom: 100%; margin-bottom: ${GAP}px; left: ${pos}; writing-mode: sideways-lr; transform: translateX(calc(-100% - ${PERP}px)); text-align: end;`;
-			case 'bottom':
-				// Reads top-to-bottom, label RIGHT of wire. Anchor at top-left
-				// (= label's bottom-left if you tilt your head left to read).
-				return `top: 100%; margin-top: ${GAP}px; left: ${pos}; writing-mode: sideways-rl; transform: translateX(${PERP}px); text-align: start;`;
-		}
-	}
-
 	// Check if this is a Subsystem or Interface node (using shapes utility)
 	const isSubsystemNode = $derived(isSubsystem(data));
 	const isInterfaceNode = $derived(data.type === NODE_TYPES.INTERFACE);
@@ -306,38 +239,10 @@
 		}
 	}
 
-	// Add input port
-	function handleAddInput(event: MouseEvent) {
-		event.stopPropagation();
-		historyStore.mutate(() => graphStore.addInputPort(id));
-	}
-
 	// Get min ports from type definition
 	const minInputs = $derived(typeDef?.ports.minInputs ?? 1);
 	const minOutputs = $derived(typeDef?.ports.minOutputs ?? 1);
 
-	// Remove input port (respects minInputs)
-	function handleRemoveInput(event: MouseEvent) {
-		event.stopPropagation();
-		if (data.inputs.length > minInputs) {
-			historyStore.mutate(() => graphStore.removeInputPort(id));
-		}
-	}
-
-	// Add output port
-	function handleAddOutput(event: MouseEvent) {
-		event.stopPropagation();
-		historyStore.mutate(() => graphStore.addOutputPort(id));
-	}
-
-	// Remove output port (respects minOutputs)
-	function handleRemoveOutput(event: MouseEvent) {
-		event.stopPropagation();
-		if (data.outputs.length > minOutputs) {
-			historyStore.mutate(() => graphStore.removeOutputPort(id));
-		}
-	}
-
 	// Get shape class from unified shapes utility
 	const shapeClass = $derived(() => typeDef ? getShapeCssClass(typeDef) : 'shape-default');
 
@@ -369,54 +274,6 @@
 		return String(value);
 	}
 
-	// Tooltip position for input handles (show tooltip away from node)
-	function getInputTooltipPosition(): 'bottom' | 'left' | 'right' | 'top' {
-		switch (rotation) {
-			case 1: return 'top';    // inputs on top → tooltip above
-			case 2: return 'right';  // inputs on right → tooltip to right
-			case 3: return 'bottom'; // inputs on bottom → tooltip below
-			default: return 'left';  // inputs on left → tooltip to left
-		}
-	}
-
-	// Tooltip position for output handles (show tooltip away from node)
-	function getOutputTooltipPosition(): 'bottom' | 'left' | 'right' | 'top' {
-		switch (rotation) {
-			case 1: return 'bottom'; // outputs on bottom → tooltip below
-			case 2: return 'left';   // outputs on left → tooltip to left
-			case 3: return 'top';    // outputs on top → tooltip above
-			default: return 'right'; // outputs on right → tooltip to right
-		}
-	}
-
-	// Handle mouse events for input handles. The hover tooltip is suppressed
-	// when port labels are already shown — the label IS the name, no point
-	// also popping a tooltip on top of it.
-	function handleInputMouseEnter(event: MouseEvent, port: { id: string; name: string }) {
-		hoveredHandle.set({ nodeId: id, handleId: port.id, color: nodeColor });
-		if (!hasVisibleInputLabels) {
-			showTooltip(port.name, event.currentTarget as HTMLElement, getInputTooltipPosition());
-		}
-	}
-
-	function handleInputMouseLeave(_port: { id: string }) {
-		hoveredHandle.set(null);
-		hideTooltip();
-	}
-
-	// Handle mouse events for output handles
-	function handleOutputMouseEnter(event: MouseEvent, port: { id: string; name: string }) {
-		hoveredHandle.set({ nodeId: id, handleId: port.id, color: nodeColor });
-		if (!hasVisibleOutputLabels) {
-			showTooltip(port.name, event.currentTarget as HTMLElement, getOutputTooltipPosition());
-		}
-	}
-
-	function handleOutputMouseLeave(_port: { id: string }) {
-		hoveredHandle.set(null);
-		hideTooltip();
-	}
-
 	// Highlight connected edges when node is selected
 	$effect(() => {
 		if (selected) {
@@ -510,77 +367,23 @@
 		{/if}
 	</div>
 
-	<!-- Port labels: rendered outside the block bounds so the block size
-	     stays the same whether labels are shown or not. The matching label
-	     for the currently-hovered handle picks up the node accent color. -->
-	{#if hasVisibleInputLabels}
-		{#each data.inputs as port, i}
-			<span
-				class="port-label"
-				class:hovered={$hoveredHandle?.handleId === port.id}
-				style={portLabelStyle(true, i, data.inputs.length)}
-			>
-				{truncatePortLabel(port.name)}
-			</span>
-		{/each}
-	{/if}
-	{#if hasVisibleOutputLabels}
-		{#each data.outputs as port, i}
-			<span
-				class="port-label"
-				class:hovered={$hoveredHandle?.handleId === port.id}
-				style={portLabelStyle(false, i, data.outputs.length)}
-			>
-				{truncatePortLabel(port.name)}
-			</span>
-		{/each}
-	{/if}
-
-	<!-- Port controls for dynamic inputs (only show when selected) -->
-	{#if allowsDynamicInputs && selected}
-		<div class="port-controls port-controls-input" class:port-controls-left={rotation === 0} class:port-controls-top={rotation === 1} class:port-controls-right={rotation === 2} class:port-controls-bottom={rotation === 3}>
-			<button class="port-btn" onclick={handleAddInput} ondblclick={(e) => e.stopPropagation()} title="Add input">+</button>
-			<button class="port-btn" onclick={handleRemoveInput} ondblclick={(e) => e.stopPropagation()} disabled={data.inputs.length <= minInputs} title="Remove input">-</button>
-		</div>
-	{/if}
-
-	<!-- Port controls for dynamic outputs (only show when selected, hide for syncPorts blocks) -->
-	{#if allowsDynamicOutputs && selected && !syncPorts}
-		<div class="port-controls port-controls-output" class:port-controls-right={rotation === 0} class:port-controls-bottom={rotation === 1} class:port-controls-left={rotation === 2} class:port-controls-top={rotation === 3}>
-			<button class="port-btn" onclick={handleAddOutput} ondblclick={(e) => e.stopPropagation()} title="Add output">+</button>
-			<button class="port-btn" onclick={handleRemoveOutput} ondblclick={(e) => e.stopPropagation()} disabled={data.outputs.length <= minOutputs} title="Remove output">-</button>
-		</div>
-	{/if}
-
-	<!-- Input handles -->
-	{#key `${rotation}-${data.inputs.length}`}
-		{#each data.inputs as port, i}
-			<Handle
-				type="target"
-				position={inputPosition()}
-				id={port.id}
-				style={isVertical ? `left: ${getPortPositionCalc(i, data.inputs.length)};` : `top: ${getPortPositionCalc(i, data.inputs.length)};`}
-				class="handle handle-input"
-				onmouseenter={(e) => handleInputMouseEnter(e, port)}
-				onmouseleave={() => handleInputMouseLeave(port)}
-			/>
-		{/each}
-	{/key}
-
-	<!-- Output handles -->
-	{#key `${rotation}-${data.outputs.length}`}
-		{#each data.outputs as port, i}
-			<Handle
-				type="source"
-				position={outputPosition()}
-				id={port.id}
-				style={isVertical ? `left: ${getPortPositionCalc(i, data.outputs.length)};` : `top: ${getPortPositionCalc(i, data.outputs.length)};`}
-				class="handle handle-output"
-				onmouseenter={(e) => handleOutputMouseEnter(e, port)}
-				onmouseleave={() => handleOutputMouseLeave(port)}
-			/>
-		{/each}
-	{/key}
+	<!-- Output port controls are hidden for syncPorts blocks, whose outputs follow the inputs -->
+	<NodePorts
+		{id}
+		inputs={data.inputs}
+		outputs={data.outputs}
+		{rotation}
+		{nodeColor}
+		{selected}
+		{showInputLabels}
+		{showOutputLabels}
+		dynamicInputs={allowsDynamicInputs}
+		dynamicOutputs={allowsDynamicOutputs && !syncPorts}
+		{minInputs}
+		{minOutputs}
+		busInputs={busPorts.get(id)?.inputs}
+		busOutputs={busPorts.get(id)?.outputs}
+	/>
 </div>
 
 <style>
@@ -827,69 +630,6 @@
 		color: var(--text-muted);
 	}
 
-	/* Port controls (+/- buttons) */
-	.port-controls {
-		position: absolute;
-		display: flex;
-		gap: 2px;
-		z-index: 10;
-	}
-
-	.port-controls-left {
-		left: -24px;
-		top: 50%;
-		transform: translateY(-50%);
-		flex-direction: column;
-	}
-
-	.port-controls-right {
-		right: -24px;
-		top: 50%;
-		transform: translateY(-50%);
-		flex-direction: column;
-	}
-
-	.port-controls-top {
-		top: -24px;
-		left: 50%;
-		transform: translateX(-50%);
-		flex-direction: row;
-	}
-
-	.port-controls-bottom {
-		bottom: -24px;
-		left: 50%;
-		transform: translateX(-50%);
-		flex-direction: row;
-	}
-
-	.port-btn {
-		width: 16px;
-		height: 16px;
-		padding: 0;
-		border: 1px solid var(--node-color);
-		border-radius: var(--radius-sm);
-		background: var(--surface-raised);
-		color: var(--node-color);
-		font-size: 12px;
-		font-weight: 600;
-		line-height: 1;
-		cursor: pointer;
-		display: flex;
-		align-items: center;
-		justify-content: center;
-	}
-
-	.port-btn:hover:not(:disabled) {
-		background: var(--node-color);
-		color: var(--surface-raised);
-	}
-
-	.port-btn:disabled {
-		opacity: 0.3;
-		cursor: not-allowed;
-	}
-
 	/* Handles - Hollow arrow/pentagon shape with rounded corners */
 	:global(.node .svelte-flow__handle) {
 		width: 10px;
@@ -1029,31 +769,4 @@
 			opacity: 1;
 		}
 	}
-
-	/* Port labels: rendered as absolutely-positioned spans on the .node
-	 * container, sitting just outside the block edge next to their handle.
-	 * Position math (which edge, perpendicular offset, text-align) is set
-	 * inline by portLabelStyle() — only typography lives in CSS. */
-	.port-label {
-		position: absolute;
-		font-size: 8px;
-		line-height: 1;
-		color: var(--text-muted);
-		white-space: nowrap;
-		overflow: hidden;
-		text-overflow: ellipsis;
-		max-width: 64px;
-		pointer-events: none;
-		transition: color 0.12s;
-	}
-
-	/* Highlight labels in the node accent color when either:
-	 *  - the block is selected, or
-	 *  - a port handle is hovered (only that single label).
-	 * The colour comes from --node-color set on the parent .node. */
-	.node.selected .port-label,
-	.port-label.hovered {
-		color: var(--node-color, var(--accent));
-		font-weight: 500;
-	}
 </style>
diff --git a/src/lib/components/nodes/BusBlockNode.svelte b/src/lib/components/nodes/BusBlockNode.svelte
new file mode 100644
index 00000000..9a108261
--- /dev/null
+++ b/src/lib/components/nodes/BusBlockNode.svelte
@@ -0,0 +1,180 @@
+<script lang="ts">
+	import { get } from 'svelte/store';
+	import { useUpdateNodeInternals } from '@xyflow/svelte';
+	import type { NodeInstance, PortDirection } from '$lib/nodes';
+	import InlineInput from '$lib/components/InlineInput.svelte';
+	import { graphStore } from '$lib/stores/graph';
+	import { historyStore } from '$lib/stores/history';
+	import { inlineEdit, editInline } from '$lib/stores/inlineEdit.svelte';
+	import { busCreatorSignals, busSelectorOptions } from '$lib/stores/busView.svelte';
+	import { selectedSignals } from '$lib/bus/expand';
+	import { renamedSignals, selectorUses } from '$lib/bus/rename';
+	import { confirmationStore } from '$lib/stores/confirmation';
+	import { portLabelsStore } from '$lib/stores/portLabels';
+	import { NODE_TYPES } from '$lib/constants/nodeTypes';
+	import { busBlockDimensions } from '$lib/constants/dimensions';
+	import { openNodeDialog } from '$lib/stores/nodeDialog';
+	import { selectedNodeHighlight } from '$lib/stores/hoveredHandle';
+	import NodePorts from './NodePorts.svelte';
+	import BusWedge from './BusWedge.svelte';
+
+	/**
+	 * Bus Creator and Bus Selector drawn as a narrow wedge instead of a block.
+	 * The wide side carries the separate signals, the narrow side the bus.
+	 * Port labels follow the port label settings, like blocks.
+	 */
+	interface Props {
+		id: string;
+		data: NodeInstance;
+		selected?: boolean;
+	}
+
+	let { id, data, selected = false }: Props = $props();
+
+	const updateNodeInternals = useUpdateNodeInternals();
+
+	const rotation = $derived((data.params?.['_rotation'] as number) || 0);
+	const isCreator = $derived(data.type === NODE_TYPES.BUS_CREATOR);
+	const size = $derived(busBlockDimensions(data.inputs.length, data.outputs.length, rotation));
+	const nodeColor = $derived(data.color || 'var(--accent)');
+
+	// Port labels follow the global setting unless the block overrides it, like blocks
+	const showInputLabels = $derived((data.params?.['_showInputLabels'] as boolean | undefined) ?? $portLabelsStore);
+	const showOutputLabels = $derived((data.params?.['_showOutputLabels'] as boolean | undefined) ?? $portLabelsStore);
+
+	// Re-measure handles when the wedge changes size or orientation
+	$effect(() => {
+		void size;
+		updateNodeInternals(id);
+	});
+
+	// Highlight connected edges when selected, like blocks do
+	$effect(() => {
+		if (selected) {
+			selectedNodeHighlight.set({ nodeId: id, color: nodeColor });
+		} else {
+			selectedNodeHighlight.update((current) => (current?.nodeId === id ? null : current));
+		}
+	});
+
+	// Signal names are edited inline like connection labels, addressed as "<node>:<direction>:<index>"
+	const editingLabel = $derived(
+		inlineEdit.targetId?.startsWith(`${id}:`) ? inlineEdit.targetId.slice(id.length + 1) : null
+	);
+
+	const signalName = (direction: PortDirection, index: number) =>
+		direction === 'input'
+			? (busCreatorSignals.get(id)?.[index] ?? data.inputs[index]?.name ?? '')
+			: (data.outputs[index]?.name ?? '');
+
+	// A selector output offers the bus signals no other output picks yet
+	function signalOptions(index: number): string[] {
+		const picked = selectedSignals(data);
+		return (busSelectorOptions.get(id) ?? []).filter((path) => path === picked[index] || !picked.includes(path));
+	}
+
+	/**
+	 * A creator input names its signal with the label of the incoming wire, or
+	 * with its port name while nothing is connected. A selector output picks a
+	 * signal from the bus.
+	 */
+	async function commitSignalName(direction: PortDirection, index: number, text: string) {
+		if (inlineEdit.targetId !== `${id}:${direction}:${index}`) return;
+		editInline(null);
+		const name = text.trim();
+		const previous = signalName(direction, index);
+		if (name === previous) return;
+
+		if (direction === 'output') {
+			historyStore.mutate(() => graphStore.setSelectorSignal(id, index, name));
+			return;
+		}
+		const wire = get(graphStore.connections).find((c) => c.targetNodeId === id && c.targetPortIndex === index);
+		if (!wire && !name) return;
+
+		// Selectors picking this signal, here or in subsystems, can follow the rename after asking
+		const source = { path: graphStore.getCurrentPath(), creatorId: id, input: index };
+		const before = graphStore.toJSON();
+		const uses = selectorUses(before.nodes, before.connections, source);
+		const everywhere =
+			uses.length > 0 &&
+			(await confirmationStore.show({
+				title: 'Rename signal everywhere?',
+				message: `"${previous}" is picked by ${uses.length} Bus Selector ${uses.length === 1 ? 'output' : 'outputs'}. Rename it there too?`,
+				confirmText: 'Rename everywhere',
+				cancelText: 'Only here'
+			}));
+
+		historyStore.mutate(() => {
+			if (wire) graphStore.updateConnectionLabel(wire.id, name);
+			else graphStore.updateNodePortName(id, 'input', index, name);
+			if (!everywhere) return;
+			const after = graphStore.toJSON();
+			graphStore.setSelectorSignalsAt(renamedSignals(after.nodes, after.connections, source, uses));
+		});
+	}
+
+	// Only signal names are edited; the bus port on the narrow side is not
+	function startLabelEdit(direction: PortDirection, index: number) {
+		if (direction === (isCreator ? 'output' : 'input')) return;
+		editInline(`${id}:${direction}:${index}`);
+	}
+</script>
+
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div
+	class="node bus-block"
+	class:selected
+	data-rotation={rotation}
+	style="width: {size.width}px; height: {size.height}px; --node-color: {nodeColor};"
+	ondblclick={(e) => {
+		e.stopPropagation();
+		openNodeDialog(id);
+	}}
+>
+	<div class="wedge">
+		<BusWedge creator={isCreator} length={Math.max(size.width, size.height)} {rotation} {selected} />
+	</div>
+
+	<!-- The narrow side is always the bus port; a creator takes more inputs, a selector's outputs follow its signals -->
+	<NodePorts
+		{id}
+		inputs={data.inputs}
+		outputs={data.outputs}
+		{rotation}
+		{nodeColor}
+		{selected}
+		{showInputLabels}
+		{showOutputLabels}
+		dynamicInputs={isCreator}
+		minInputs={1}
+		inputNames={isCreator ? busCreatorSignals.get(id) : undefined}
+		busInputs={isCreator ? undefined : [0]}
+		busOutputs={isCreator ? [0] : undefined}
+		signalLabels
+		{editingLabel}
+		onLabelEdit={startLabelEdit}
+		{labelEditor}
+	/>
+</div>
+
+{#snippet labelEditor(direction: PortDirection, index: number)}
+	<InlineInput
+		value={signalName(direction, index)}
+		placeholder="Signal"
+		suggestions={direction === 'output' ? signalOptions(index) : undefined}
+		onCommit={(text) => commitSignalName(direction, index, text)}
+		onCancel={() => editInline(null)}
+	/>
+{/snippet}
+
+<style>
+	.bus-block {
+		position: relative;
+	}
+
+	.wedge {
+		position: absolute;
+		inset: 0;
+	}
+</style>
diff --git a/src/lib/components/nodes/BusWedge.svelte b/src/lib/components/nodes/BusWedge.svelte
new file mode 100644
index 00000000..1b17745d
--- /dev/null
+++ b/src/lib/components/nodes/BusWedge.svelte
@@ -0,0 +1,86 @@
+<script lang="ts">
+	import { BUS } from '$lib/constants/dimensions';
+	import { roundedPolygonPath } from '$lib/utils/svgPath';
+
+	/**
+	 * Bus Creator or Bus Selector symbol, shared by the canvas and the library.
+	 * A trapezoid with rounded corners: the wide side carries the separate
+	 * signals, the narrow side the bus. The narrow side is set in by the same
+	 * amount at any length, so the angles never change.
+	 */
+	interface Props {
+		creator: boolean;
+		/** Size along the ports in pixels */
+		length: number;
+		/** Quarter turns, like block rotation */
+		rotation?: number;
+		selected?: boolean;
+	}
+
+	let { creator, length, rotation = 0, selected = false }: Props = $props();
+
+	const vertical = $derived(rotation === 1 || rotation === 3);
+
+	// Trapezoid in the unrotated frame, wide side left for a creator and right for a selector
+	const shape = $derived.by(() => {
+		const w = BUS.blockWidth;
+		const inset = BUS.wedgeInset;
+		const corners: [number, number][] = creator
+			? [[0, 0], [w, inset], [w, length - inset], [0, length]]
+			: [[0, inset], [w, 0], [w, length], [0, length - inset]];
+		return roundedPolygonPath(corners, BUS.cornerRadius);
+	});
+
+	// Turn the unrotated frame into the box: the input side moves like block inputs do
+	const frame = $derived.by(() => {
+		switch (rotation) {
+			case 1: return `translate(${length}, 0) rotate(90)`;
+			case 2: return `translate(${BUS.blockWidth}, ${length}) rotate(180)`;
+			case 3: return `translate(0, ${BUS.blockWidth}) rotate(270)`;
+			default: return undefined;
+		}
+	});
+</script>
+
+<svg
+	class="bus-wedge"
+	class:selected
+	width={vertical ? length : BUS.blockWidth}
+	height={vertical ? BUS.blockWidth : length}
+>
+	<g transform={frame}>
+		<path class="halo" d={shape} />
+		<path class="body" d={shape} />
+	</g>
+</svg>
+
+<style>
+	.bus-wedge {
+		display: block;
+		overflow: visible;
+	}
+
+	.body {
+		fill: var(--surface-raised);
+		stroke: var(--edge);
+		stroke-width: 1;
+		stroke-linejoin: round;
+		transition: stroke 0.15s ease;
+	}
+
+	/* Selection ring like the block box-shadow: a wide translucent stroke behind the body */
+	.halo {
+		fill: none;
+		stroke: transparent;
+		stroke-width: 5;
+		stroke-linejoin: round;
+	}
+
+	.selected .body {
+		stroke: var(--node-color, var(--accent));
+	}
+
+	.selected .halo {
+		stroke: color-mix(in srgb, var(--node-color, var(--accent)) 25%, transparent);
+	}
+</style>
diff --git a/src/lib/components/nodes/NodePorts.svelte b/src/lib/components/nodes/NodePorts.svelte
new file mode 100644
index 00000000..8399b845
--- /dev/null
+++ b/src/lib/components/nodes/NodePorts.svelte
@@ -0,0 +1,422 @@
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	import { Handle, Position } from '@xyflow/svelte';
+	import type { PortDirection, PortInstance } from '$lib/nodes/types';
+	import { graphStore } from '$lib/stores/graph';
+	import { historyStore } from '$lib/stores/history';
+	import { hoveredHandle } from '$lib/stores/hoveredHandle';
+	import { showTooltip, hideTooltip } from '$lib/components/Tooltip.svelte';
+	import { getPortPositionCalc } from '$lib/constants/dimensions';
+	import { truncatePortLabel } from '$lib/utils/portLabels';
+
+	/**
+	 * Ports of a block node: handles, port labels and the +/- controls for blocks
+	 * with a variable port count. Sits inside the node element, whose edges
+	 * everything is positioned against.
+	 */
+	interface Props {
+		id: string;
+		inputs: PortInstance[];
+		outputs: PortInstance[];
+		rotation: number;
+		nodeColor: string;
+		selected: boolean;
+		showInputLabels: boolean;
+		showOutputLabels: boolean;
+		/** Inputs and outputs can be added and removed while the block is selected */
+		dynamicInputs?: boolean;
+		dynamicOutputs?: boolean;
+		minInputs?: number;
+		minOutputs?: number;
+		/** Names shown for the inputs instead of the port names, e.g. derived signal names */
+		inputNames?: string[];
+		/** Indices of ports carrying a bus, drawn with the bus handle */
+		busInputs?: number[];
+		busOutputs?: number[];
+		/** Labels are signal names: styled like connection labels and editable with a double-click */
+		signalLabels?: boolean;
+		/** Label being edited as "input:0" or "output:1", rendered by labelEditor */
+		editingLabel?: string | null;
+		onLabelEdit?: (direction: PortDirection, index: number) => void;
+		labelEditor?: Snippet<[PortDirection, number]>;
+	}
+
+	let {
+		id,
+		inputs,
+		outputs,
+		rotation,
+		nodeColor,
+		selected,
+		showInputLabels,
+		showOutputLabels,
+		dynamicInputs = false,
+		dynamicOutputs = false,
+		minInputs = 1,
+		minOutputs = 1,
+		inputNames,
+		busInputs,
+		busOutputs,
+		signalLabels = false,
+		editingLabel = null,
+		onLabelEdit,
+		labelEditor
+	}: Props = $props();
+
+	const isEditing = (direction: PortDirection, index: number) =>
+		labelEditor !== undefined && editingLabel === `${direction}:${index}`;
+
+	function handleLabelDoubleClick(event: MouseEvent, direction: PortDirection, index: number) {
+		if (!onLabelEdit) return;
+		event.stopPropagation();
+		onLabelEdit(direction, index);
+	}
+
+	// Actual visibility: setting is ON and ports exist (single source of truth)
+	const hasVisibleInputLabels = $derived(showInputLabels && inputs.length > 0);
+	const hasVisibleOutputLabels = $derived(showOutputLabels && outputs.length > 0);
+
+	const inputName = (port: PortInstance, index: number) => inputNames?.[index] ?? port.name;
+
+	const handleClass = (direction: 'input' | 'output', index: number) => {
+		const bus = (direction === 'input' ? busInputs : busOutputs)?.includes(index);
+		return `handle handle-${direction}${bus ? ' handle-bus' : ''}`;
+	};
+
+	// Calculate actual port positions based on rotation
+	// 0: inputs left, outputs right (default)
+	// 1: inputs top, outputs bottom
+	// 2: inputs right, outputs left
+	// 3: inputs bottom, outputs top
+	const inputPosition = $derived.by(() => {
+		switch (rotation) {
+			case 1: return Position.Top;
+			case 2: return Position.Right;
+			case 3: return Position.Bottom;
+			default: return Position.Left;
+		}
+	});
+
+	const outputPosition = $derived.by(() => {
+		switch (rotation) {
+			case 1: return Position.Bottom;
+			case 2: return Position.Left;
+			case 3: return Position.Top;
+			default: return Position.Right;
+		}
+	});
+
+	// Port is horizontal (left/right) or vertical (top/bottom)
+	const isVertical = $derived(rotation === 1 || rotation === 3);
+
+	/** Inline style for a port label, positioning it outside the block edge
+	 *  next to its handle. The handle/wire is always *below* the label from
+	 *  the label's perspective — i.e. the anchor point sits at the label's
+	 *  bottom-left or bottom-right corner.
+	 *
+	 *  Horizontal block: text horizontal, label sits just above the wire stub.
+	 *  Vertical block: `writing-mode: sideways-{lr|rl}` rotates the text
+	 *    parallel to the wire (no transform tricks needed for positioning,
+	 *    so the perpendicular offset works in screen-space directly). Top
+	 *    edge reads bottom-to-top, bottom edge top-to-bottom — both read
+	 *    *outward* from the block. */
+	function portLabelStyle(isInput: boolean, portIndex: number, total: number): string {
+		const pos = getPortPositionCalc(portIndex, total);
+		const GAP = 10; // distance from block edge along the wire
+		const PERP = 5; // perpendicular offset off the wire path
+
+		// Map (rotation, isInput) → which block edge hosts the port.
+		let edge: 'left' | 'right' | 'top' | 'bottom';
+		if (rotation === 0) edge = isInput ? 'left' : 'right';
+		else if (rotation === 2) edge = isInput ? 'right' : 'left';
+		else if (rotation === 1) edge = isInput ? 'top' : 'bottom';
+		else edge = isInput ? 'bottom' : 'top';
+
+		switch (edge) {
+			case 'left':
+				// Anchor (port) at label bottom-right.
+				return `right: 100%; margin-right: ${GAP}px; top: ${pos}; transform: translateY(calc(-100% - ${PERP}px)); text-align: right;`;
+			case 'right':
+				// Anchor at label bottom-left.
+				return `left: 100%; margin-left: ${GAP}px; top: ${pos}; transform: translateY(calc(-100% - ${PERP}px)); text-align: left;`;
+			case 'top':
+				// Reads bottom-to-top, label LEFT of wire. Anchor at bottom-right.
+				return `bottom: 100%; margin-bottom: ${GAP}px; left: ${pos}; writing-mode: sideways-lr; transform: translateX(calc(-100% - ${PERP}px)); text-align: end;`;
+			case 'bottom':
+				// Reads top-to-bottom, label RIGHT of wire. Anchor at top-left
+				// (= label's bottom-left if you tilt your head left to read).
+				return `top: 100%; margin-top: ${GAP}px; left: ${pos}; writing-mode: sideways-rl; transform: translateX(${PERP}px); text-align: start;`;
+		}
+	}
+
+	// Tooltip position for input handles (show tooltip away from node)
+	function getInputTooltipPosition(): 'bottom' | 'left' | 'right' | 'top' {
+		switch (rotation) {
+			case 1: return 'top';    // inputs on top → tooltip above
+			case 2: return 'right';  // inputs on right → tooltip to right
+			case 3: return 'bottom'; // inputs on bottom → tooltip below
+			default: return 'left';  // inputs on left → tooltip to left
+		}
+	}
+
+	// Tooltip position for output handles (show tooltip away from node)
+	function getOutputTooltipPosition(): 'bottom' | 'left' | 'right' | 'top' {
+		switch (rotation) {
+			case 1: return 'bottom'; // outputs on bottom → tooltip below
+			case 2: return 'left';   // outputs on left → tooltip to left
+			case 3: return 'top';    // outputs on top → tooltip above
+			default: return 'right'; // outputs on right → tooltip to right
+		}
+	}
+
+	// Handle mouse events for input handles. The hover tooltip is suppressed
+	// when port labels are already shown — the label IS the name, no point
+	// also popping a tooltip on top of it.
+	function handleInputMouseEnter(event: MouseEvent, name: string, handleId: string) {
+		hoveredHandle.set({ nodeId: id, handleId, color: nodeColor });
+		if (!hasVisibleInputLabels) {
+			showTooltip(name, event.currentTarget as HTMLElement, getInputTooltipPosition());
+		}
+	}
+
+	// Handle mouse events for output handles
+	function handleOutputMouseEnter(event: MouseEvent, name: string, handleId: string) {
+		hoveredHandle.set({ nodeId: id, handleId, color: nodeColor });
+		if (!hasVisibleOutputLabels) {
+			showTooltip(name, event.currentTarget as HTMLElement, getOutputTooltipPosition());
+		}
+	}
+
+	function handleMouseLeave() {
+		hoveredHandle.set(null);
+		hideTooltip();
+	}
+
+	// Port count controls; removal respects the minimum port count
+	function changePorts(event: MouseEvent, change: () => void) {
+		event.stopPropagation();
+		historyStore.mutate(change);
+	}
+</script>
+
+<!-- Port labels: rendered outside the block bounds so the block size
+     stays the same whether labels are shown or not. The matching label
+     for the currently-hovered handle picks up the node accent color. -->
+{#if hasVisibleInputLabels}
+	{#each inputs as port, i}
+		<!-- svelte-ignore a11y_no_static_element_interactions -->
+		<span
+			class="port-label"
+			class:signal={signalLabels}
+			class:editing={isEditing('input', i)}
+			class:nodrag={isEditing('input', i)}
+			class:hovered={$hoveredHandle?.handleId === port.id}
+			style={portLabelStyle(true, i, inputs.length)}
+			ondblclick={(e) => handleLabelDoubleClick(e, 'input', i)}
+		>
+			{#if isEditing('input', i)}
+				{@render labelEditor?.('input', i)}
+			{:else}
+				{truncatePortLabel(inputName(port, i))}
+			{/if}
+		</span>
+	{/each}
+{/if}
+{#if hasVisibleOutputLabels}
+	{#each outputs as port, i}
+		<!-- svelte-ignore a11y_no_static_element_interactions -->
+		<span
+			class="port-label"
+			class:signal={signalLabels}
+			class:editing={isEditing('output', i)}
+			class:nodrag={isEditing('output', i)}
+			class:hovered={$hoveredHandle?.handleId === port.id}
+			style={portLabelStyle(false, i, outputs.length)}
+			ondblclick={(e) => handleLabelDoubleClick(e, 'output', i)}
+		>
+			{#if isEditing('output', i)}
+				{@render labelEditor?.('output', i)}
+			{:else}
+				{truncatePortLabel(port.name)}
+			{/if}
+		</span>
+	{/each}
+{/if}
+
+<!-- Port controls for dynamic inputs (only show when selected) -->
+{#if dynamicInputs && selected}
+	<div class="port-controls" class:port-controls-left={rotation === 0} class:port-controls-top={rotation === 1} class:port-controls-right={rotation === 2} class:port-controls-bottom={rotation === 3}>
+		<button class="port-btn" onclick={(e) => changePorts(e, () => graphStore.addInputPort(id))} ondblclick={(e) => e.stopPropagation()} title="Add input">+</button>
+		<button class="port-btn" onclick={(e) => changePorts(e, () => graphStore.removeInputPort(id))} ondblclick={(e) => e.stopPropagation()} disabled={inputs.length <= minInputs} title="Remove input">-</button>
+	</div>
+{/if}
+
+<!-- Port controls for dynamic outputs (only show when selected) -->
+{#if dynamicOutputs && selected}
+	<div class="port-controls" class:port-controls-right={rotation === 0} class:port-controls-bottom={rotation === 1} class:port-controls-left={rotation === 2} class:port-controls-top={rotation === 3}>
+		<button class="port-btn" onclick={(e) => changePorts(e, () => graphStore.addOutputPort(id))} ondblclick={(e) => e.stopPropagation()} title="Add output">+</button>
+		<button class="port-btn" onclick={(e) => changePorts(e, () => graphStore.removeOutputPort(id))} ondblclick={(e) => e.stopPropagation()} disabled={outputs.length <= minOutputs} title="Remove output">-</button>
+	</div>
+{/if}
+
+<!-- Input handles -->
+{#key `${rotation}-${inputs.length}`}
+	{#each inputs as port, i}
+		<Handle
+			type="target"
+			position={inputPosition}
+			id={port.id}
+			style={isVertical ? `left: ${getPortPositionCalc(i, inputs.length)};` : `top: ${getPortPositionCalc(i, inputs.length)};`}
+			class={handleClass('input', i)}
+			onmouseenter={(e) => handleInputMouseEnter(e, inputName(port, i), port.id)}
+			onmouseleave={handleMouseLeave}
+		/>
+	{/each}
+{/key}
+
+<!-- Output handles -->
+{#key `${rotation}-${outputs.length}`}
+	{#each outputs as port, i}
+		<Handle
+			type="source"
+			position={outputPosition}
+			id={port.id}
+			style={isVertical ? `left: ${getPortPositionCalc(i, outputs.length)};` : `top: ${getPortPositionCalc(i, outputs.length)};`}
+			class={handleClass('output', i)}
+			onmouseenter={(e) => handleOutputMouseEnter(e, port.name, port.id)}
+			onmouseleave={handleMouseLeave}
+		/>
+	{/each}
+{/key}
+
+<style>
+	/* Port labels: rendered as absolutely-positioned spans on the .node
+	 * container, sitting just outside the block edge next to their handle.
+	 * Position math (which edge, perpendicular offset, text-align) is set
+	 * inline by portLabelStyle() — only typography lives in CSS. */
+	.port-label {
+		position: absolute;
+		font-size: 8px;
+		line-height: 1;
+		color: var(--text-muted);
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		max-width: 64px;
+		pointer-events: none;
+		transition: color 0.12s;
+	}
+
+	/* Highlight labels in the node accent color when either:
+	 *  - the block is selected, or
+	 *  - a port handle is hovered (only that single label).
+	 * The colour comes from --node-color set on the parent .node. */
+	:global(.node.selected) .port-label,
+	.port-label.hovered {
+		color: var(--node-color, var(--accent));
+		font-weight: 500;
+	}
+
+	/* Signal names on bus blocks look like connection labels: UI font with a
+	 * halo in the canvas color. They take pointer events for the double-click. */
+	.port-label.signal {
+		font-family: var(--font-ui);
+		font-size: var(--font-xs);
+		font-weight: 400;
+		text-shadow: 0 0 2px var(--surface), 0 0 2px var(--surface), 0 0 2px var(--surface);
+		pointer-events: auto;
+		cursor: text;
+	}
+
+	.port-label.editing {
+		max-width: none;
+		overflow: visible;
+		text-shadow: none;
+	}
+
+	/* Port controls (+/- buttons) */
+	.port-controls {
+		position: absolute;
+		display: flex;
+		gap: 2px;
+		z-index: 10;
+	}
+
+	.port-controls-left {
+		left: -24px;
+		top: 50%;
+		transform: translateY(-50%);
+		flex-direction: column;
+	}
+
+	.port-controls-right {
+		right: -24px;
+		top: 50%;
+		transform: translateY(-50%);
+		flex-direction: column;
+	}
+
+	.port-controls-top {
+		top: -24px;
+		left: 50%;
+		transform: translateX(-50%);
+		flex-direction: row;
+	}
+
+	.port-controls-bottom {
+		bottom: -24px;
+		left: 50%;
+		transform: translateX(-50%);
+		flex-direction: row;
+	}
+
+	.port-btn {
+		width: 16px;
+		height: 16px;
+		padding: 0;
+		border: 1px solid var(--node-color);
+		border-radius: var(--radius-sm);
+		background: var(--surface-raised);
+		color: var(--node-color);
+		font-size: 12px;
+		font-weight: 600;
+		line-height: 1;
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+
+	.port-btn:hover:not(:disabled) {
+		background: var(--node-color);
+		color: var(--surface-raised);
+	}
+
+	.port-btn:disabled {
+		opacity: 0.3;
+		cursor: not-allowed;
+	}
+
+	/* Ports carrying a bus: the same arrow as other ports with a heavier outline,
+	 * matching the thicker bus wire. Like other ports it fills on hover and selection. */
+	:global(.node .svelte-flow__handle.handle-bus::after) {
+		inset: 1.5px;
+	}
+
+	/* Inner cutouts, 1.5px inside the outer arrow */
+	:global(.node[data-rotation="0"] .svelte-flow__handle.handle-bus::after) {
+		clip-path: path('M 0.6 0 L 3.5 0 Q 3.9 0 4.2 0.3 L 6.1 2.2 Q 6.4 2.5 6.1 2.8 L 4.2 4.7 Q 3.9 5 3.5 5 L 0.6 5 Q 0 5 0 4.4 L 0 0.6 Q 0 0 0.6 0 Z');
+	}
+
+	:global(.node[data-rotation="1"] .svelte-flow__handle.handle-bus::after) {
+		clip-path: path('M 0 0.6 L 0 3.5 Q 0 3.9 0.3 4.2 L 2.2 6.1 Q 2.5 6.4 2.8 6.1 L 4.7 4.2 Q 5 3.9 5 3.5 L 5 0.6 Q 5 0 4.4 0 L 0.6 0 Q 0 0 0 0.6 Z');
+	}
+
+	:global(.node[data-rotation="2"] .svelte-flow__handle.handle-bus::after) {
+		clip-path: path('M 6.4 0 L 3.5 0 Q 3.1 0 2.8 0.3 L 0.9 2.2 Q 0.6 2.5 0.9 2.8 L 2.8 4.7 Q 3.1 5 3.5 5 L 6.4 5 Q 7 5 7 4.4 L 7 0.6 Q 7 0 6.4 0 Z');
+	}
+
+	:global(.node[data-rotation="3"] .svelte-flow__handle.handle-bus::after) {
+		clip-path: path('M 0 6.4 L 0 3.5 Q 0 3.1 0.3 2.8 L 2.2 0.9 Q 2.5 0.6 2.8 0.9 L 4.7 2.8 Q 5 3.1 5 3.5 L 5 6.4 Q 5 7 4.4 7 L 0.6 7 Q 0 7 0 6.4 Z');
+	}
+</style>
diff --git a/src/lib/components/nodes/NodePreview.svelte b/src/lib/components/nodes/NodePreview.svelte
index 75b152b8..377b2944 100644
--- a/src/lib/components/nodes/NodePreview.svelte
+++ b/src/lib/components/nodes/NodePreview.svelte
@@ -1,6 +1,9 @@
 <script lang="ts">
 	import type { NodeTypeDefinition } from '$lib/nodes/types';
 	import { getShapeCssClass } from '$lib/nodes/shapes';
+	import { NODE_TYPES } from '$lib/constants/nodeTypes';
+	import { busBlockDimensions } from '$lib/constants/dimensions';
+	import BusWedge from './BusWedge.svelte';
 
 	interface Props {
 		node: NodeTypeDefinition;
@@ -10,11 +13,22 @@
 
 	const isSubsystemType = $derived(node.category === 'Subsystem');
 	const shapeClass = $derived(() => getShapeCssClass(node));
+
+	// Bus blocks show their symbol instead of a block card
+	const isBus = $derived(node.type === NODE_TYPES.BUS_CREATOR || node.type === NODE_TYPES.BUS_SELECTOR);
+	const busLength = $derived(busBlockDimensions(node.ports.inputs.length, node.ports.outputs.length, 0).height);
 </script>
 
-<div class="node-preview {shapeClass()}" class:subsystem-type={isSubsystemType}>
-	<span class="node-name">{node.name}</span>
-</div>
+{#if isBus}
+	<div class="node-preview bus-preview">
+		<BusWedge creator={node.type === NODE_TYPES.BUS_CREATOR} length={busLength} />
+		<span class="node-name">{node.name}</span>
+	</div>
+{:else}
+	<div class="node-preview {shapeClass()}" class:subsystem-type={isSubsystemType}>
+		<span class="node-name">{node.name}</span>
+	</div>
+{/if}
 
 <style>
 	.node-preview {
@@ -29,6 +43,12 @@
 		transition: all 0.15s ease;
 	}
 
+	.bus-preview {
+		gap: var(--space-sm);
+		background: none;
+		border-color: transparent;
+	}
+
 	.shape-pill { border-radius: 20px; }
 	.shape-rect { border-radius: 4px; }
 	.shape-circle { border-radius: 16px; }
diff --git a/src/lib/components/panels/NodeLibrary.svelte b/src/lib/components/panels/NodeLibrary.svelte
index cd842047..61689072 100644
--- a/src/lib/components/panels/NodeLibrary.svelte
+++ b/src/lib/components/panels/NodeLibrary.svelte
@@ -6,6 +6,7 @@
 	import { getBackendType } from '$lib/pyodide/backend';
 	import { createHoverDetail } from '$lib/actions/hoverDetail.svelte';
 	import NodePreview from '$lib/components/nodes/NodePreview.svelte';
+	import { BUS_CATEGORY } from '$lib/constants/nodeTypes';
 	import Icon from '$lib/components/icons/Icon.svelte';
 	interface Props {
 		onAddNode?: (type: string) => void;
@@ -62,9 +63,9 @@
 		}
 	}
 
-	// Built-in category order from blockConfig + Subsystem (registered separately).
+	// Built-in category order from blockConfig + buses and Subsystem (registered separately).
 	// Runtime-added categories are appended in registration order after these.
-	const builtInCategoryOrder: NodeCategory[] = [...(Object.keys(blockConfig) as NodeCategory[]), 'Subsystem'];
+	const builtInCategoryOrder: NodeCategory[] = [...(Object.keys(blockConfig) as NodeCategory[]), BUS_CATEGORY, 'Subsystem'];
 
 	// Filter nodes based on search and context. Read registryTick so the
 	// derived re-runs whenever the registry changes (toolbox install/uninstall).
diff --git a/src/lib/components/panels/library-detail/CanvasBlockPreview.svelte b/src/lib/components/panels/library-detail/CanvasBlockPreview.svelte
index 371dc82f..49028d0c 100644
--- a/src/lib/components/panels/library-detail/CanvasBlockPreview.svelte
+++ b/src/lib/components/panels/library-detail/CanvasBlockPreview.svelte
@@ -1,7 +1,9 @@
 <script lang="ts">
 	import type { NodeTypeDefinition } from '$lib/nodes/types';
 	import { getShapeCssClass, isSubsystem } from '$lib/nodes/shapes';
-	import { calculateNodeDimensions, getPortPositionCalc } from '$lib/constants/dimensions';
+	import { busBlockDimensions, calculateNodeDimensions, getPortPositionCalc } from '$lib/constants/dimensions';
+	import { NODE_TYPES } from '$lib/constants/nodeTypes';
+	import BusWedge from '$lib/components/nodes/BusWedge.svelte';
 
 	interface Props {
 		node: NodeTypeDefinition;
@@ -14,19 +16,30 @@
 
 	const shapeClass = $derived(getShapeCssClass(node));
 	const isSubsystemType = $derived(isSubsystem(node) || node.category === 'Subsystem');
+	// Bus blocks are drawn as their wedge symbol, at canvas size
+	const isBus = $derived(node.type === NODE_TYPES.BUS_CREATOR || node.type === NODE_TYPES.BUS_SELECTOR);
 	const dimensions = $derived(
-		calculateNodeDimensions(node.name, inputCount, outputCount, 0, 0, undefined, null, false)
+		isBus
+			? busBlockDimensions(inputCount, outputCount, 0)
+			: calculateNodeDimensions(node.name, inputCount, outputCount, 0, 0, undefined, null, false)
 	);
 </script>
 
 <div
 	class="cbp-node {shapeClass}"
 	class:subsystem-type={isSubsystemType}
+	class:bus={isBus}
 	style="width: {dimensions.width}px; height: {dimensions.height}px;"
 >
-	<div class="cbp-content">
-		<span class="cbp-name">{node.name}</span>
-	</div>
+	{#if isBus}
+		<div class="cbp-wedge">
+			<BusWedge creator={node.type === NODE_TYPES.BUS_CREATOR} length={dimensions.height} />
+		</div>
+	{:else}
+		<div class="cbp-content">
+			<span class="cbp-name">{node.name}</span>
+		</div>
+	{/if}
 
 	{#each Array(inputCount) as _, i}
 		<div class="cbp-handle cbp-handle-input" style="top: {getPortPositionCalc(i, inputCount)};"></div>
@@ -71,6 +84,17 @@
 		border-style: dashed;
 	}
 
+	/* No border: it would shrink the box the handles align to, while the wedge fills the whole box */
+	.cbp-node.bus {
+		background: none;
+		border: none;
+	}
+
+	.cbp-wedge {
+		position: absolute;
+		inset: 0;
+	}
+
 	.cbp-content {
 		position: absolute;
 		inset: 0;
diff --git a/src/lib/constants/dimensions.ts b/src/lib/constants/dimensions.ts
index 8f5f3958..b6cec8ed 100644
--- a/src/lib/constants/dimensions.ts
+++ b/src/lib/constants/dimensions.ts
@@ -36,16 +36,45 @@ export const HANDLE = {
 	hollowInset: 1.5
 } as const;
 
-/** Connection label capsule, shared by the drawn label and its inline editor */
-export const EDGE_LABEL = {
+/** Inline text input on the canvas (connection labels, bus signal names) */
+export const INLINE_INPUT = {
 	/** Capsule height in pixels */
 	height: 14,
 	/** Space between text and capsule ends in pixels */
 	paddingX: 6,
-	/** Minimum editor width in characters */
-	minChars: 5
+	/** Minimum capsule width in characters */
+	minChars: 5,
+	/** Screen distance between capsule and suggestion list in pixels */
+	listGap: 4,
+	/** Most suggestions shown at once */
+	maxSuggestions: 8
 } as const;
 
+/** Bus Creator and Bus Selector blocks, and the wires carrying buses */
+export const BUS = {
+	/** Block width across the wedge: 2 grid units */
+	blockWidth: G.x2,
+	/** How far the narrow side is set in at each end; the same at every size, so the angles never change: 1 grid unit */
+	wedgeInset: G.unit,
+	/** Corner radius of the wedge in pixels */
+	cornerRadius: 3,
+	/** Line width of a wire carrying a bus, relative to a plain connection */
+	wireScale: 2,
+	/** A bus wire starts this far inside its source port, which covers the wire end, so the thick line joins without a gap */
+	sourceInset: 4
+} as const;
+
+/**
+ * Size of a Bus Creator or Bus Selector: one port spacing per port along the
+ * wedge, at least two, and a fixed width across it. Grid-aligned like blocks.
+ */
+export function busBlockDimensions(inputCount: number, outputCount: number, rotation: number): { width: number; height: number } {
+	const length = Math.max(2, inputCount, outputCount) * NODE.portSpacing;
+	return rotation === 1 || rotation === 3
+		? { width: length, height: BUS.blockWidth }
+		: { width: BUS.blockWidth, height: length };
+}
+
 /** Event node dimensions (grid-aligned) */
 export const EVENT = {
 	/** Total bounding box size: 8 grid units = 80px */
diff --git a/src/lib/constants/nodeTypes.ts b/src/lib/constants/nodeTypes.ts
index dc841a67..392c2eae 100644
--- a/src/lib/constants/nodeTypes.ts
+++ b/src/lib/constants/nodeTypes.ts
@@ -1,10 +1,16 @@
 /**
  * Centralized node type identifiers
- * These match the PathSim block class names directly
+ * Subsystem and Interface match the PathSim block class names directly.
+ * Bus Creator and Bus Selector exist only in the editor and are resolved before code generation.
  */
 export const NODE_TYPES = {
 	SUBSYSTEM: 'Subsystem',
-	INTERFACE: 'Interface'
+	INTERFACE: 'Interface',
+	BUS_CREATOR: 'BusCreator',
+	BUS_SELECTOR: 'BusSelector'
 } as const;
 
 export type NodeTypeId = (typeof NODE_TYPES)[keyof typeof NODE_TYPES];
+
+/** Library category of the editor-only bus blocks */
+export const BUS_CATEGORY = 'Buses';
diff --git a/src/lib/constants/python.ts b/src/lib/constants/python.ts
index 985b7364..67bdb285 100644
--- a/src/lib/constants/python.ts
+++ b/src/lib/constants/python.ts
@@ -33,6 +33,7 @@ export const BLOCK_CATEGORY_ORDER: string[] = [
 	'Discrete',
 	'FMI',
 	'Recording',
+	'Buses',
 	'Subsystem'
 ];
 
diff --git a/src/lib/nodes/buses.ts b/src/lib/nodes/buses.ts
new file mode 100644
index 00000000..67ce00c4
--- /dev/null
+++ b/src/lib/nodes/buses.ts
@@ -0,0 +1,49 @@
+/**
+ * Bus block definitions
+ * Bus Creator and Bus Selector exist only in the editor; they are resolved
+ * into direct wiring before code generation (see $lib/bus/expand).
+ */
+
+import { defineNode } from './defineNode';
+import { nodeRegistry } from './registry';
+import { BUS_CATEGORY, NODE_TYPES } from '$lib/constants/nodeTypes';
+
+/** Bus Creator - bundles its input signals into one bus */
+export const BusCreatorDefinition = defineNode({
+	name: 'Bus Creator',
+	category: BUS_CATEGORY,
+	blockClass: NODE_TYPES.BUS_CREATOR,
+	description:
+		'Bundles its input signals into one bus. A signal is named after the label of its wire, or else the port it comes from.',
+	inputs: ['in 0', 'in 1'],
+	outputs: ['bus'],
+	minInputs: 1,
+	maxInputs: null,
+	minOutputs: 1,
+	maxOutputs: 1,
+	shape: 'rect',
+	params: {}
+});
+
+/** Bus Selector - picks signals out of a bus; its outputs follow the picked signals */
+export const BusSelectorDefinition = defineNode({
+	name: 'Bus Selector',
+	category: BUS_CATEGORY,
+	blockClass: NODE_TYPES.BUS_SELECTOR,
+	description: 'Picks signals out of a bus by name, one output per picked signal.',
+	inputs: ['bus'],
+	outputs: [],
+	minInputs: 1,
+	maxInputs: 1,
+	minOutputs: 0,
+	maxOutputs: 0,
+	shape: 'rect',
+	params: {
+		signals: { type: 'any', default: [], description: 'Signal paths picked from the bus, one output each' }
+	}
+});
+
+export function registerBusNodes(): void {
+	nodeRegistry.register(BusCreatorDefinition);
+	nodeRegistry.register(BusSelectorDefinition);
+}
diff --git a/src/lib/nodes/index.ts b/src/lib/nodes/index.ts
index 3561e69d..dcd3a7b8 100644
--- a/src/lib/nodes/index.ts
+++ b/src/lib/nodes/index.ts
@@ -21,3 +21,9 @@ registerSubsystemNodes();
 
 // Re-export subsystem definitions
 export { SubsystemDefinition, InterfaceDefinition } from './subsystem';
+
+// Register editor-only bus blocks
+import { registerBusNodes } from './buses';
+registerBusNodes();
+
+export { BusCreatorDefinition, BusSelectorDefinition } from './buses';
diff --git a/src/lib/pyodide/mutationQueue.ts b/src/lib/pyodide/mutationQueue.ts
index f9a3d79a..b0cfe344 100644
--- a/src/lib/pyodide/mutationQueue.ts
+++ b/src/lib/pyodide/mutationQueue.ts
@@ -20,6 +20,7 @@ import { writable } from 'svelte/store';
 import type { NodeInstance, Connection } from '$lib/nodes/types';
 import { nodeRegistry } from '$lib/nodes/registry';
 import { isSubsystem } from '$lib/nodes/shapes';
+import { isBusBlock } from '$lib/bus/expand';
 import { sanitizeName } from './codeBuilder';
 
 // --- Command types ---
@@ -143,7 +144,8 @@ export function hasPendingMutations(): boolean {
  */
 export function queueAddBlock(node: NodeInstance): void {
 	if (!isActive()) return;
-	if (isSubsystem(node)) return;
+	// Bus blocks have no pathsim counterpart; wiring through them applies on the next run
+	if (isSubsystem(node) || isBusBlock(node)) return;
 
 	const typeDef = nodeRegistry.get(node.type);
 	if (!typeDef) return;
diff --git a/src/lib/pyodide/pathsimRunner.ts b/src/lib/pyodide/pathsimRunner.ts
index 338b95a6..ac8e42b3 100644
--- a/src/lib/pyodide/pathsimRunner.ts
+++ b/src/lib/pyodide/pathsimRunner.ts
@@ -15,6 +15,7 @@ import { blockImportPaths } from '$lib/nodes/generated/blocks';
 import { ENGINE_MODULE, enginePath } from '$lib/constants/engine';
 import { generateEngineSetup } from './engineCodegen';
 import { graphStore, findParentSubsystem } from '$lib/stores/graph';
+import { expandBuses, isBusBlock } from '$lib/bus/expand';
 import {
 	runStreamingSimulation,
 	validateGraph as validateGraphBridge,
@@ -788,8 +789,9 @@ export async function runGraphStreamingSimulation(
 	events: EventInstance[] = [],
 	onUpdate?: (result: SimulationResult) => void
 ): Promise<SimulationResult | null> {
-	// Generate code without sim.run() - streaming will handle execution
-	const result = generatePythonCode(nodes, connections, settings, codeContext, true, events, false);
+	// Generate code without sim.run() - streaming will handle execution; bus blocks are wired directly
+	const model = expandBuses(nodes, connections);
+	const result = generatePythonCode(model.nodes, model.connections, settings, codeContext, true, events, false);
 	const duration = getSettingOrDefault(settings, 'duration');
 	return runStreamingSimulation(result.code, String(duration), onUpdate, result.nodeVars, result.connVars);
 }
@@ -804,7 +806,8 @@ export function exportToPython(
 	codeContext: string,
 	events: EventInstance[] = []
 ): string {
-	return generateFormattedPythonCode(nodes, connections, settings, codeContext, events);
+	const model = expandBuses(nodes, connections);
+	return generateFormattedPythonCode(model.nodes, model.connections, settings, codeContext, events);
 }
 
 /**
@@ -819,6 +822,10 @@ export function generateBlockCode(
 	const typeDef = nodeRegistry.get(node.type);
 	if (!typeDef) return '';
 
+	if (isBusBlock(node)) {
+		return '# Bus blocks exist only in the editor; the generated code wires their signals directly';
+	}
+
 	// Handle Interface blocks - generate parent Subsystem code instead
 	if (node.type === NODE_TYPES.INTERFACE) {
 		const rootNodes = allNodes || graphStore.getAllNodes();
@@ -837,7 +844,9 @@ export function generateBlockCode(
 		const nodeVars = new Map<string, string>();
 		const varNames: string[] = [];
 
-		generateSubsystemCode(node, nodeVars, varNames, lines, '', { formatted: true });
+		// Buses entering from outside the subsystem are not known here; buses inside it are resolved
+		const [expanded] = expandBuses([node], []).nodes;
+		generateSubsystemCode(expanded, nodeVars, varNames, lines, '', { formatted: true });
 
 		return lines.join('\n');
 	}
@@ -878,7 +887,8 @@ function extractNodeParams(nodes: NodeInstance[]): Record<string, Record<string,
 
 	for (const node of nodes) {
 		const typeDef = nodeRegistry.get(node.type);
-		if (!typeDef) continue;
+		// Bus block params are signal names, not Python expressions
+		if (!typeDef || isBusBlock(node)) continue;
 
 		const validParamNames = new Set(typeDef.params.map((p) => p.name));
 		const nodeParams: Record<string, string> = {};
diff --git a/src/lib/stores/busView.svelte.ts b/src/lib/stores/busView.svelte.ts
new file mode 100644
index 00000000..caf835df
--- /dev/null
+++ b/src/lib/stores/busView.svelte.ts
@@ -0,0 +1,89 @@
+/**
+ * Bus view - bus facts of the current graph level, for rendering
+ *
+ * Computed centrally whenever the canvas rebuilds its edges, so a wire or bus
+ * block only re-renders when its own entry changes. Bus structure follows wires
+ * across all levels, so the whole model is analyzed.
+ */
+
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
+import type { Connection, NodeInstance } from '$lib/nodes/types';
+import { NODE_TYPES } from '$lib/constants/nodeTypes';
+import { analyzeBuses, containsBusBlocks, signalPaths } from '$lib/bus/expand';
+
+/** Wires carrying a bus */
+export const busWires = new SvelteSet<string>();
+
+/** Bus Creator ID to the signal name of each of its inputs */
+export const busCreatorSignals = new SvelteMap<string, string[]>();
+
+/** Node ID to the indices of its ports that carry a bus; absent when none does */
+export const busPorts = new SvelteMap<string, { inputs: number[]; outputs: number[] }>();
+
+/** Bus Selector ID to the signal paths on the bus at its input */
+export const busSelectorOptions = new SvelteMap<string, string[]>();
+
+/** Wires into a Bus Creator: their label is the signal name and shows at the creator port instead */
+export const busCreatorWires = new SvelteSet<string>();
+
+function sync<T>(target: SvelteMap<string, T>, next: Map<string, T>, same: (a: T, b: T) => boolean): void {
+	for (const key of [...target.keys()]) {
+		if (!next.has(key)) target.delete(key);
+	}
+	for (const [key, value] of next) {
+		const current = target.get(key);
+		if (current === undefined || !same(current, value)) target.set(key, value);
+	}
+}
+
+function syncSet(target: SvelteSet<string>, next: Set<string>): void {
+	for (const key of [...target]) {
+		if (!next.has(key)) target.delete(key);
+	}
+	for (const key of next) target.add(key);
+}
+
+const sameNames = (a: string[], b: string[]) => a.length === b.length && a.every((name, i) => name === b[i]);
+const sameIndices = (a: number[], b: number[]) => a.length === b.length && a.every((index, i) => index === b[i]);
+
+/**
+ * Recompute the bus view for the connections of the graph level at `path`
+ * @param model - Root nodes and connections of the whole model
+ */
+export function updateBusView(
+	model: { nodes: NodeInstance[]; connections: Connection[] },
+	path: string[],
+	connections: Connection[]
+): void {
+	const wires = new Set<string>();
+	const creators = new Map<string, string[]>();
+	const ports = new Map<string, { inputs: number[]; outputs: number[] }>();
+	const selectorOptions = new Map<string, string[]>();
+	const creatorWires = new Set<string>();
+
+	if (containsBusBlocks(model.nodes)) {
+		const analysis = analyzeBuses(model.nodes, model.connections);
+		const level = analysis.levelAt(path);
+		if (level) {
+			for (const connection of connections) {
+				if (analysis.structureOut(level, connection.sourceNodeId, connection.sourcePortIndex)) wires.add(connection.id);
+				if (level.nodes.get(connection.targetNodeId)?.type === NODE_TYPES.BUS_CREATOR) creatorWires.add(connection.id);
+			}
+			for (const node of level.nodeList) {
+				if (node.type === NODE_TYPES.BUS_CREATOR) creators.set(node.id, analysis.elementNames(level, node));
+				if (node.type === NODE_TYPES.BUS_SELECTOR) {
+					selectorOptions.set(node.id, signalPaths(analysis.structureIn(level, node.id, 0)).map((p) => p.path));
+				}
+				const inputs = node.inputs.flatMap((_, i) => (analysis.structureIn(level, node.id, i) ? [i] : []));
+				const outputs = node.outputs.flatMap((_, i) => (analysis.structureOut(level, node.id, i) ? [i] : []));
+				if (inputs.length > 0 || outputs.length > 0) ports.set(node.id, { inputs, outputs });
+			}
+		}
+	}
+
+	syncSet(busWires, wires);
+	sync(busCreatorSignals, creators, sameNames);
+	sync(busPorts, ports, (a, b) => sameIndices(a.inputs, b.inputs) && sameIndices(a.outputs, b.outputs));
+	sync(busSelectorOptions, selectorOptions, sameNames);
+	syncSet(busCreatorWires, creatorWires);
+}
diff --git a/src/lib/stores/edgeLabelEdit.svelte.ts b/src/lib/stores/edgeLabelEdit.svelte.ts
deleted file mode 100644
index 2e74877e..00000000
--- a/src/lib/stores/edgeLabelEdit.svelte.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-/**
- * Edge label editing - which connection currently shows the inline label editor
- */
-
-export const edgeLabelEdit = $state<{ connectionId: string | null }>({ connectionId: null });
-
-/** Open the label editor for a connection, or close it with null */
-export function editEdgeLabel(connectionId: string | null): void {
-	edgeLabelEdit.connectionId = connectionId;
-}
diff --git a/src/lib/stores/graph/buses.ts b/src/lib/stores/graph/buses.ts
new file mode 100644
index 00000000..3c7076b6
--- /dev/null
+++ b/src/lib/stores/graph/buses.ts
@@ -0,0 +1,124 @@
+/**
+ * Graph store - Bus block operations
+ */
+
+import type { NodeInstance } from '$lib/nodes/types';
+import { NODE_TYPES } from '$lib/constants/nodeTypes';
+import { selectedSignals } from '$lib/bus/expand';
+import { queueRemoveConnection } from '$lib/pyodide/mutationQueue';
+import { createPorts } from './helpers';
+import {
+	getCurrentGraph,
+	rootNodes,
+	updateCurrentNodes,
+	updateCurrentNodesAndConnections,
+	updateSubsystemGraph
+} from './state';
+
+/**
+ * Set the picked signals of Bus Selector outputs anywhere in the model, e.g. to
+ * follow a renamed signal. Outputs are named after their signal and keep their wires.
+ */
+export function setSelectorSignalsAt(
+	changes: { path: string[]; selectorId: string; output: number; signal: string }[]
+): void {
+	const byLevel = new Map<string, typeof changes>();
+	for (const change of changes) {
+		const key = change.path.join('/');
+		byLevel.set(key, [...(byLevel.get(key) ?? []), change]);
+	}
+
+	for (const group of byLevel.values()) {
+		const update = (node: NodeInstance): NodeInstance => {
+			const own = group.filter((c) => c.selectorId === node.id);
+			if (own.length === 0) return node;
+			const signals = [...selectedSignals(node)];
+			const outputs = [...node.outputs];
+			for (const change of own) {
+				signals[change.output] = change.signal;
+				if (outputs[change.output]) outputs[change.output] = { ...outputs[change.output], name: change.signal };
+			}
+			return { ...node, params: { ...node.params, signals }, outputs };
+		};
+
+		const path = group[0].path;
+		if (path.length === 0) {
+			rootNodes.update((nodes) => new Map([...nodes].map(([id, node]) => [id, update(node)])));
+		} else {
+			updateSubsystemGraph(path, (graph) => ({ ...graph, nodes: graph.nodes.map(update) }));
+		}
+	}
+}
+
+/**
+ * Set the signal one Bus Selector output picks. The output keeps its wires.
+ * A signal another output already picks is ignored.
+ */
+export function setSelectorSignal(nodeId: string, index: number, signal: string): void {
+	const node = getCurrentGraph().nodes.get(nodeId);
+	if (!node || node.type !== NODE_TYPES.BUS_SELECTOR) return;
+	const signals = selectedSignals(node);
+	const path = signal.trim();
+	if (!path || index >= signals.length || signals[index] === path || signals.includes(path)) return;
+
+	const next = signals.map((s, i) => (i === index ? path : s));
+	const update = (n: NodeInstance): NodeInstance =>
+		n.id === nodeId
+			? {
+					...n,
+					params: { ...n.params, signals: next },
+					outputs: n.outputs.map((port, i) => (i === index ? { ...port, name: path } : port))
+				}
+			: n;
+
+	updateCurrentNodes(
+		(nodes) => {
+			const current = nodes.get(nodeId);
+			if (!current) return nodes;
+			const updated = new Map(nodes);
+			updated.set(nodeId, update(current));
+			return updated;
+		},
+		(nodes) => nodes.map(update)
+	);
+}
+
+/**
+ * Set the signals a Bus Selector picks. Its outputs follow the list, one per
+ * signal and named after it. Wires stay on their signal when the list changes;
+ * wires of signals no longer picked are removed.
+ */
+export function setSelectedSignals(nodeId: string, signals: string[]): void {
+	const graph = getCurrentGraph();
+	const node = graph.nodes.get(nodeId);
+	if (!node || node.type !== NODE_TYPES.BUS_SELECTOR) return;
+
+	const previous = selectedSignals(node);
+	const nextIndex = new Map(signals.map((signal, i) => [signal, i]));
+	const outputs = createPorts(nodeId, 'output', signals.map((name) => ({ name })));
+	const update = (n: NodeInstance): NodeInstance =>
+		n.id === nodeId ? { ...n, params: { ...n.params, signals }, outputs } : n;
+
+	const connections = graph.connections.flatMap((c) => {
+		if (c.sourceNodeId !== nodeId) return [c];
+		const signal = previous[c.sourcePortIndex];
+		const port = signal === undefined ? undefined : nextIndex.get(signal);
+		if (port === undefined) {
+			queueRemoveConnection(c.id);
+			return [];
+		}
+		return port === c.sourcePortIndex ? [c] : [{ ...c, sourcePortIndex: port }];
+	});
+
+	updateCurrentNodesAndConnections(
+		(nodes) => {
+			const current = nodes.get(nodeId);
+			if (!current) return nodes;
+			const next = new Map(nodes);
+			next.set(nodeId, update(current));
+			return next;
+		},
+		(nodes) => nodes.map(update),
+		() => connections
+	);
+}
diff --git a/src/lib/stores/graph/index.ts b/src/lib/stores/graph/index.ts
index e5a91fab..9f4a5fbf 100644
--- a/src/lib/stores/graph/index.ts
+++ b/src/lib/stores/graph/index.ts
@@ -31,6 +31,7 @@ import * as nodes from './nodes';
 import * as connections from './connections';
 import * as ports from './ports';
 import * as annotations from './annotations';
+import * as buses from './buses';
 import * as subsystemEvents from './subsystemEvents';
 import * as selection from './selection';
 import * as serialization from './serialization';
@@ -94,6 +95,11 @@ export const graphStore = {
 	removeAnnotation: annotations.removeAnnotation,
 	getAnnotation: annotations.getAnnotation,
 
+	// ==================== BUS BLOCK OPERATIONS ====================
+	setSelectedSignals: buses.setSelectedSignals,
+	setSelectorSignal: buses.setSelectorSignal,
+	setSelectorSignalsAt: buses.setSelectorSignalsAt,
+
 	// ==================== SUBSYSTEM EVENT OPERATIONS ====================
 	addSubsystemEvent: subsystemEvents.addSubsystemEvent,
 	removeSubsystemEvent: subsystemEvents.removeSubsystemEvent,
diff --git a/src/lib/stores/inlineEdit.svelte.ts b/src/lib/stores/inlineEdit.svelte.ts
new file mode 100644
index 00000000..2ffb7b62
--- /dev/null
+++ b/src/lib/stores/inlineEdit.svelte.ts
@@ -0,0 +1,12 @@
+/**
+ * Inline edit state - the canvas text currently edited inline with the pill
+ * editor: a connection label (by connection ID) or a bus block signal name
+ * (by "<node>:<direction>:<index>"). One at a time.
+ */
+
+export const inlineEdit = $state<{ targetId: string | null }>({ targetId: null });
+
+/** Start editing a text inline, or stop editing with null */
+export function editInline(targetId: string | null): void {
+	inlineEdit.targetId = targetId;
+}
diff --git a/src/lib/utils/svgPath.test.ts b/src/lib/utils/svgPath.test.ts
new file mode 100644
index 00000000..d22864b6
--- /dev/null
+++ b/src/lib/utils/svgPath.test.ts
@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { roundedPolygonPath } from './svgPath';
+
+describe('roundedPolygonPath', () => {
+	it('rounds every corner of a closed polygon', () => {
+		expect(roundedPolygonPath([[0, 0], [10, 0], [10, 10], [0, 10]], 2)).toBe(
+			'M 0 2 Q 0 0 2 0 L 8 0 Q 10 0 10 2 L 10 8 Q 10 10 8 10 L 2 10 Q 0 10 0 8 Z'
+		);
+	});
+
+	it('clamps the radius to half of the shorter side', () => {
+		expect(roundedPolygonPath([[0, 0], [2, 0], [2, 10], [0, 10]], 5)).toBe(
+			'M 0 1 Q 0 0 1 0 L 1 0 Q 2 0 2 1 L 2 9 Q 2 10 1 10 L 1 10 Q 0 10 0 9 Z'
+		);
+	});
+});
diff --git a/src/lib/utils/svgPath.ts b/src/lib/utils/svgPath.ts
new file mode 100644
index 00000000..e80159d6
--- /dev/null
+++ b/src/lib/utils/svgPath.ts
@@ -0,0 +1,26 @@
+/**
+ * SVG path helpers
+ */
+
+/**
+ * Path of a closed polygon with rounded corners. The radius is clamped to half
+ * of the shorter side at each corner, so short sides never overlap.
+ */
+export function roundedPolygonPath(points: [number, number][], radius: number): string {
+	const count = points.length;
+	let d = '';
+	for (let i = 0; i < count; i++) {
+		const [px, py] = points[(i - 1 + count) % count];
+		const [cx, cy] = points[i];
+		const [nx, ny] = points[(i + 1) % count];
+		const toPrev = Math.hypot(px - cx, py - cy);
+		const toNext = Math.hypot(nx - cx, ny - cy);
+		const r = Math.min(radius, toPrev / 2, toNext / 2);
+		const startX = cx + ((px - cx) / toPrev) * r;
+		const startY = cy + ((py - cy) / toPrev) * r;
+		const endX = cx + ((nx - cx) / toNext) * r;
+		const endY = cy + ((ny - cy) / toNext) * r;
+		d += `${i === 0 ? 'M' : 'L'} ${startX} ${startY} Q ${cx} ${cy} ${endX} ${endY} `;
+	}
+	return `${d}Z`;
+}
diff --git a/tests/fixtures/bus_expansion.json b/tests/fixtures/bus_expansion.json
new file mode 100644
index 00000000..19aeba3a
--- /dev/null
+++ b/tests/fixtures/bus_expansion.json
@@ -0,0 +1,221 @@
+{
+  "description": "Bus expansion cases shared by src/lib/bus/expand.test.ts and tests/test_bus_expansion.py. Expected wiring per level as source:port>target:port; level keys are subsystem ID paths joined by '/', the root is ''.",
+  "scenarios": [
+    {
+      "name": "flat creator and selector",
+      "nodes": [
+        { "id": "A", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "B", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "C", "type": "BusCreator", "inputs": [{ "name": "in 0" }, { "name": "in 1" }], "outputs": [{ "name": "out 0" }] },
+        { "id": "S", "type": "BusSelector", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "b" }, { "name": "out 0" }], "params": { "signals": ["b", "out 0"] } },
+        { "id": "Scope", "type": "Scope", "inputs": [{ "name": "in 0" }, { "name": "in 1" }], "outputs": [] }
+      ],
+      "connections": [
+        { "id": "c1", "sourceNodeId": "A", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 0 },
+        { "id": "c2", "sourceNodeId": "B", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 1, "label": "b" },
+        { "id": "c3", "sourceNodeId": "C", "sourcePortIndex": 0, "targetNodeId": "S", "targetPortIndex": 0 },
+        { "id": "c4", "sourceNodeId": "S", "sourcePortIndex": 0, "targetNodeId": "Scope", "targetPortIndex": 0 },
+        { "id": "c5", "sourceNodeId": "S", "sourcePortIndex": 1, "targetNodeId": "Scope", "targetPortIndex": 1 }
+      ],
+      "expected": { "": ["B:0>Scope:0", "A:0>Scope:1"] }
+    },
+    {
+      "name": "duplicate names are numbered and fan-out is kept",
+      "nodes": [
+        { "id": "A", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "B", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "C", "type": "BusCreator", "inputs": [{ "name": "in 0" }, { "name": "in 1" }], "outputs": [{ "name": "out 0" }] },
+        { "id": "S", "type": "BusSelector", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "out 0_2" }], "params": { "signals": ["out 0_2"] } },
+        { "id": "X", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] },
+        { "id": "Y", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] }
+      ],
+      "connections": [
+        { "id": "c1", "sourceNodeId": "A", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 0 },
+        { "id": "c2", "sourceNodeId": "B", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 1 },
+        { "id": "c3", "sourceNodeId": "C", "sourcePortIndex": 0, "targetNodeId": "S", "targetPortIndex": 0 },
+        { "id": "c4", "sourceNodeId": "S", "sourcePortIndex": 0, "targetNodeId": "X", "targetPortIndex": 0 },
+        { "id": "c5", "sourceNodeId": "S", "sourcePortIndex": 0, "targetNodeId": "Y", "targetPortIndex": 0 }
+      ],
+      "expected": { "": ["B:0>X:0", "B:0>Y:0"] }
+    },
+    {
+      "name": "nested buses and selecting a sub-bus",
+      "nodes": [
+        { "id": "A", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "B", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "D", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "C1", "type": "BusCreator", "inputs": [{ "name": "in 0" }, { "name": "in 1" }], "outputs": [{ "name": "out 0" }] },
+        { "id": "C2", "type": "BusCreator", "inputs": [{ "name": "in 0" }, { "name": "in 1" }], "outputs": [{ "name": "out 0" }] },
+        { "id": "S", "type": "BusSelector", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "inner.b" }, { "name": "d" }, { "name": "inner" }], "params": { "signals": ["inner.b", "d", "inner"] } },
+        { "id": "S2", "type": "BusSelector", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "a" }], "params": { "signals": ["a"] } },
+        { "id": "X", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] },
+        { "id": "Y", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] },
+        { "id": "Z", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] }
+      ],
+      "connections": [
+        { "id": "c1", "sourceNodeId": "A", "sourcePortIndex": 0, "targetNodeId": "C1", "targetPortIndex": 0, "label": "a" },
+        { "id": "c2", "sourceNodeId": "B", "sourcePortIndex": 0, "targetNodeId": "C1", "targetPortIndex": 1, "label": "b" },
+        { "id": "c3", "sourceNodeId": "C1", "sourcePortIndex": 0, "targetNodeId": "C2", "targetPortIndex": 0, "label": "inner" },
+        { "id": "c4", "sourceNodeId": "D", "sourcePortIndex": 0, "targetNodeId": "C2", "targetPortIndex": 1, "label": "d" },
+        { "id": "c5", "sourceNodeId": "C2", "sourcePortIndex": 0, "targetNodeId": "S", "targetPortIndex": 0 },
+        { "id": "c6", "sourceNodeId": "S", "sourcePortIndex": 0, "targetNodeId": "X", "targetPortIndex": 0 },
+        { "id": "c7", "sourceNodeId": "S", "sourcePortIndex": 1, "targetNodeId": "Y", "targetPortIndex": 0 },
+        { "id": "c8", "sourceNodeId": "S", "sourcePortIndex": 2, "targetNodeId": "S2", "targetPortIndex": 0 },
+        { "id": "c9", "sourceNodeId": "S2", "sourcePortIndex": 0, "targetNodeId": "Z", "targetPortIndex": 0 }
+      ],
+      "expected": { "": ["B:0>X:0", "D:0>Y:0", "A:0>Z:0"] }
+    },
+    {
+      "name": "bus into a subsystem",
+      "nodes": [
+        { "id": "A", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "B", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "C", "type": "BusCreator", "inputs": [{ "name": "in 0" }, { "name": "in 1" }], "outputs": [{ "name": "out 0" }] },
+        {
+          "id": "Sub", "type": "Subsystem", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "out 0" }],
+          "graph": {
+            "nodes": [
+              { "id": "I", "type": "Interface", "inputs": [{ "name": "out 0" }], "outputs": [{ "name": "in 0" }] },
+              { "id": "Sel", "type": "BusSelector", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "b" }], "params": { "signals": ["b"] } },
+              { "id": "G", "type": "Amplifier", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "out 0" }] }
+            ],
+            "connections": [
+              { "id": "s1", "sourceNodeId": "I", "sourcePortIndex": 0, "targetNodeId": "Sel", "targetPortIndex": 0 },
+              { "id": "s2", "sourceNodeId": "Sel", "sourcePortIndex": 0, "targetNodeId": "G", "targetPortIndex": 0 },
+              { "id": "s3", "sourceNodeId": "G", "sourcePortIndex": 0, "targetNodeId": "I", "targetPortIndex": 0 }
+            ]
+          }
+        },
+        { "id": "Scope", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] }
+      ],
+      "connections": [
+        { "id": "c1", "sourceNodeId": "A", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 0, "label": "a" },
+        { "id": "c2", "sourceNodeId": "B", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 1, "label": "b" },
+        { "id": "c3", "sourceNodeId": "C", "sourcePortIndex": 0, "targetNodeId": "Sub", "targetPortIndex": 0 },
+        { "id": "c4", "sourceNodeId": "Sub", "sourcePortIndex": 0, "targetNodeId": "Scope", "targetPortIndex": 0 }
+      ],
+      "expected": {
+        "": ["A:0>Sub:0", "B:0>Sub:1", "Sub:0>Scope:0"],
+        "Sub": ["I:1>G:0", "G:0>I:0"]
+      }
+    },
+    {
+      "name": "bus out of a subsystem",
+      "nodes": [
+        {
+          "id": "Sub", "type": "Subsystem", "inputs": [], "outputs": [{ "name": "out 0" }],
+          "graph": {
+            "nodes": [
+              { "id": "I", "type": "Interface", "inputs": [{ "name": "out 0" }], "outputs": [] },
+              { "id": "G1", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+              { "id": "G2", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+              { "id": "C", "type": "BusCreator", "inputs": [{ "name": "in 0" }, { "name": "in 1" }], "outputs": [{ "name": "out 0" }] }
+            ],
+            "connections": [
+              { "id": "s1", "sourceNodeId": "G1", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 0, "label": "x" },
+              { "id": "s2", "sourceNodeId": "G2", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 1, "label": "y" },
+              { "id": "s3", "sourceNodeId": "C", "sourcePortIndex": 0, "targetNodeId": "I", "targetPortIndex": 0 }
+            ]
+          }
+        },
+        { "id": "Sel", "type": "BusSelector", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "y" }], "params": { "signals": ["y"] } },
+        { "id": "Scope", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] }
+      ],
+      "connections": [
+        { "id": "c1", "sourceNodeId": "Sub", "sourcePortIndex": 0, "targetNodeId": "Sel", "targetPortIndex": 0 },
+        { "id": "c2", "sourceNodeId": "Sel", "sourcePortIndex": 0, "targetNodeId": "Scope", "targetPortIndex": 0 }
+      ],
+      "expected": {
+        "": ["Sub:1>Scope:0"],
+        "Sub": ["G1:0>I:0", "G2:0>I:1"]
+      }
+    },
+    {
+      "name": "bus through two subsystem levels",
+      "nodes": [
+        { "id": "A", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "B", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "C", "type": "BusCreator", "inputs": [{ "name": "in 0" }, { "name": "in 1" }], "outputs": [{ "name": "out 0" }] },
+        {
+          "id": "Outer", "type": "Subsystem", "inputs": [{ "name": "in 0" }], "outputs": [],
+          "graph": {
+            "nodes": [
+              { "id": "I1", "type": "Interface", "inputs": [], "outputs": [{ "name": "in 0" }] },
+              {
+                "id": "Inner", "type": "Subsystem", "inputs": [{ "name": "in 0" }], "outputs": [],
+                "graph": {
+                  "nodes": [
+                    { "id": "I2", "type": "Interface", "inputs": [], "outputs": [{ "name": "in 0" }] },
+                    { "id": "Sel", "type": "BusSelector", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "a" }], "params": { "signals": ["a"] } },
+                    { "id": "G", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] }
+                  ],
+                  "connections": [
+                    { "id": "i1", "sourceNodeId": "I2", "sourcePortIndex": 0, "targetNodeId": "Sel", "targetPortIndex": 0 },
+                    { "id": "i2", "sourceNodeId": "Sel", "sourcePortIndex": 0, "targetNodeId": "G", "targetPortIndex": 0 }
+                  ]
+                }
+              }
+            ],
+            "connections": [
+              { "id": "o1", "sourceNodeId": "I1", "sourcePortIndex": 0, "targetNodeId": "Inner", "targetPortIndex": 0 }
+            ]
+          }
+        }
+      ],
+      "connections": [
+        { "id": "c1", "sourceNodeId": "A", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 0, "label": "a" },
+        { "id": "c2", "sourceNodeId": "B", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 1, "label": "b" },
+        { "id": "c3", "sourceNodeId": "C", "sourcePortIndex": 0, "targetNodeId": "Outer", "targetPortIndex": 0 }
+      ],
+      "expected": {
+        "": ["A:0>Outer:0", "B:0>Outer:1"],
+        "Outer": ["I1:0>Inner:0", "I1:1>Inner:1"],
+        "Outer/Inner": ["I2:0>G:0"]
+      }
+    },
+    {
+      "name": "unresolvable wiring is left out",
+      "nodes": [
+        { "id": "A", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "C", "type": "BusCreator", "inputs": [{ "name": "in 0" }, { "name": "in 1" }], "outputs": [{ "name": "out 0" }] },
+        { "id": "Sel", "type": "BusSelector", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "a" }, { "name": "missing" }], "params": { "signals": ["a", "missing"] } },
+        { "id": "X", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] },
+        { "id": "Y", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] },
+        { "id": "Scope", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] }
+      ],
+      "connections": [
+        { "id": "c1", "sourceNodeId": "A", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 0, "label": "a" },
+        { "id": "c2", "sourceNodeId": "C", "sourcePortIndex": 0, "targetNodeId": "Sel", "targetPortIndex": 0 },
+        { "id": "c3", "sourceNodeId": "Sel", "sourcePortIndex": 0, "targetNodeId": "X", "targetPortIndex": 0 },
+        { "id": "c4", "sourceNodeId": "Sel", "sourcePortIndex": 1, "targetNodeId": "Y", "targetPortIndex": 0 },
+        { "id": "c5", "sourceNodeId": "C", "sourcePortIndex": 0, "targetNodeId": "Scope", "targetPortIndex": 0 }
+      ],
+      "expected": { "": ["A:0>X:0"] }
+    },
+    {
+      "name": "wire loop through bus blocks terminates",
+      "nodes": [
+        { "id": "A", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "C", "type": "BusCreator", "inputs": [{ "name": "in 0" }, { "name": "in 1" }], "outputs": [{ "name": "out 0" }] },
+        { "id": "S", "type": "BusSelector", "inputs": [{ "name": "in 0" }], "outputs": [{ "name": "loop" }], "params": { "signals": ["loop"] } }
+      ],
+      "connections": [
+        { "id": "c1", "sourceNodeId": "A", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 0, "label": "a" },
+        { "id": "c2", "sourceNodeId": "C", "sourcePortIndex": 0, "targetNodeId": "S", "targetPortIndex": 0 },
+        { "id": "c3", "sourceNodeId": "S", "sourcePortIndex": 0, "targetNodeId": "C", "targetPortIndex": 1, "label": "loop" }
+      ],
+      "expected": { "": [] }
+    },
+    {
+      "name": "model without buses is unchanged",
+      "nodes": [
+        { "id": "A", "type": "Constant", "inputs": [], "outputs": [{ "name": "out 0" }] },
+        { "id": "X", "type": "Scope", "inputs": [{ "name": "in 0" }], "outputs": [] }
+      ],
+      "connections": [
+        { "id": "c1", "sourceNodeId": "A", "sourcePortIndex": 0, "targetNodeId": "X", "targetPortIndex": 0 }
+      ],
+      "expected": { "": ["A:0>X:0"] }
+    }
+  ]
+}
diff --git a/tests/test_bus_expansion.py b/tests/test_bus_expansion.py
new file mode 100644
index 00000000..d417042c
--- /dev/null
+++ b/tests/test_bus_expansion.py
@@ -0,0 +1,66 @@
+"""Bus expansion: the Python converter resolves bus blocks like the editor does."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from pathview.buses import expand_buses, is_bus_block
+from pathview.converter import generate_python, load_registry
+
+FIXTURES = json.loads((Path(__file__).parent / "fixtures" / "bus_expansion.json").read_text())
+REGISTRY_PATH = Path(__file__).parent.parent / "pathview" / "data" / "registry.json"
+
+
+def _wiring(connections):
+    return sorted(
+        f"{c['sourceNodeId']}:{c['sourcePortIndex']}>{c['targetNodeId']}:{c['targetPortIndex']}"
+        for c in connections
+    )
+
+
+def _levels(nodes, connections, path=""):
+    """Wiring per level, keyed by subsystem ID path."""
+    result = {path: _wiring(connections)}
+    for node in nodes:
+        graph = node.get("graph")
+        if graph:
+            child = f"{path}/{node['id']}" if path else node["id"]
+            result.update(_levels(graph.get("nodes", []), graph.get("connections", []), child))
+    return result
+
+
+def _any_bus_block(nodes):
+    return any(
+        is_bus_block(n) or (bool(n.get("graph")) and _any_bus_block(n["graph"].get("nodes", [])))
+        for n in nodes
+    )
+
+
+@pytest.mark.parametrize("scenario", FIXTURES["scenarios"], ids=lambda s: s["name"])
+def test_expansion_matches_fixture(scenario):
+    nodes, connections = expand_buses(scenario["nodes"], scenario["connections"])
+    expected = {key: sorted(value) for key, value in scenario["expected"].items()}
+    assert _levels(nodes, connections) == expected
+    assert not _any_bus_block(nodes)
+
+
+def test_model_without_buses_is_unchanged():
+    scenario = next(s for s in FIXTURES["scenarios"] if "without buses" in s["name"])
+    nodes, connections = expand_buses(scenario["nodes"], scenario["connections"])
+    assert nodes is scenario["nodes"]
+    assert connections is scenario["connections"]
+
+
+def test_converter_generates_no_bus_blocks():
+    scenario = next(s for s in FIXTURES["scenarios"] if s["name"] == "bus into a subsystem")
+    pvm = {"version": "1.0.0", "graph": {"nodes": scenario["nodes"], "connections": scenario["connections"]}}
+    for node in pvm["graph"]["nodes"]:
+        node.setdefault("name", node["id"])
+        node.setdefault("params", {})
+        for child in (node.get("graph") or {}).get("nodes", []):
+            child.setdefault("name", child["id"])
+            child.setdefault("params", {})
+    code = generate_python(pvm, load_registry(REGISTRY_PATH))
+    assert "BusCreator" not in code
+    assert "BusSelector" not in code