Keep single-device circuit names equal to their device row

A circuit with exactly one device row and no fed distribution board is
shown as that row, so its own name was hidden and could drift (e.g.
"Neuer Stromkreis" in the print view). Commands that create or leave
such a circuit, rename its row or unlink its downstream board now set
the circuit name to the row name and store the change as optional
circuitDisplayNames, so Undo restores an overwritten free name exactly.
Migration 0016 aligns existing data.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/domain/models/circuit-device-row-move-project-command.model.ts

@@ -1,4 +1,9 @@
 import type { SerializedProjectCommand } from "./project-command.model.js";
+import {
+  assertCircuitDisplayNameTransitions,
+  withCircuitDisplayNames,
+  type CircuitDisplayNameTransition,
+} from "./circuit-display-name-sync.model.js";
 import {
   assertCircuitInsertProjectCommand,
   circuitInsertCommandType,
@@ -22,6 +27,7 @@ export interface CircuitDeviceRowMoveAssignment {
 
 export interface CircuitDeviceRowMoveCommandPayload {
   moves: CircuitDeviceRowMoveAssignment[];
+  circuitDisplayNames?: CircuitDisplayNameTransition[];
 }
 
 export interface CircuitDeviceRowMoveProjectCommand
@@ -38,6 +44,7 @@ export interface CircuitDeviceRowMoveWithNewCircuitCommandPayload {
   targetCircuitAction: CircuitDeviceRowMoveTargetCircuitAction;
   targetCircuit: CircuitSnapshot;
   moves: CircuitDeviceRowMoveAssignment[];
+  circuitDisplayNames?: CircuitDisplayNameTransition[];
 }
 
 export interface CircuitDeviceRowMoveWithNewCircuitProjectCommand
@@ -51,12 +58,13 @@ export type CircuitDeviceRowMoveHistoryProjectCommand =
   | CircuitDeviceRowMoveWithNewCircuitProjectCommand;
 
 export function createCircuitDeviceRowMoveProjectCommand(
-  moves: CircuitDeviceRowMoveAssignment[]
+  moves: CircuitDeviceRowMoveAssignment[],
+  circuitDisplayNames?: CircuitDisplayNameTransition[]
 ): CircuitDeviceRowMoveProjectCommand {
   const command: CircuitDeviceRowMoveProjectCommand = {
     schemaVersion: circuitDeviceRowMoveCommandSchemaVersion,
     type: circuitDeviceRowMoveCommandType,
-    payload: { moves },
+    payload: withCircuitDisplayNames({ moves }, circuitDisplayNames),
   };
   assertCircuitDeviceRowMoveProjectCommand(command);
   return command;
@@ -65,16 +73,20 @@ export function createCircuitDeviceRowMoveProjectCommand(
 export function createCircuitDeviceRowMoveWithNewCircuitProjectCommand(
   targetCircuitAction: CircuitDeviceRowMoveTargetCircuitAction,
   targetCircuit: CircuitSnapshot,
-  moves: CircuitDeviceRowMoveAssignment[]
+  moves: CircuitDeviceRowMoveAssignment[],
+  circuitDisplayNames?: CircuitDisplayNameTransition[]
 ): CircuitDeviceRowMoveWithNewCircuitProjectCommand {
   const command: CircuitDeviceRowMoveWithNewCircuitProjectCommand = {
     schemaVersion: circuitDeviceRowMoveCommandSchemaVersion,
     type: circuitDeviceRowMoveWithNewCircuitCommandType,
-    payload: {
-      targetCircuitAction,
-      targetCircuit,
-      moves,
-    },
+    payload: withCircuitDisplayNames(
+      {
+        targetCircuitAction,
+        targetCircuit,
+        moves,
+      },
+      circuitDisplayNames
+    ),
   };
   assertCircuitDeviceRowMoveWithNewCircuitProjectCommand(command);
   return command;
@@ -135,6 +147,7 @@ export function assertCircuitDeviceRowMoveProjectCommand(
 
     rowIds.add(move.rowId);
   }
+  assertCircuitDisplayNameTransitions(command.payload.circuitDisplayNames);
 }
 
 export function assertCircuitDeviceRowMoveWithNewCircuitProjectCommand(
@@ -205,6 +218,7 @@ export function assertCircuitDeviceRowMoveWithNewCircuitProjectCommand(
       );
     }
   }
+  assertCircuitDisplayNameTransitions(command.payload.circuitDisplayNames);
 }
 
 function assertNonEmptyString(

src/domain/models/circuit-device-row-project-command.model.ts

@@ -1,3 +1,6 @@
+// The frontend imports this model as a value, so it keeps type-only imports.
+// The repository validates the stored circuitDisplayNames.
+import type { CircuitDisplayNameTransition } from "./circuit-display-name-sync.model.js";
 import type { SerializedProjectCommand } from "./project-command.model.js";
 
 export const circuitDeviceRowUpdateCommandType =
@@ -40,6 +43,7 @@ export interface CircuitDeviceRowUpdateFieldChange<
 export interface CircuitDeviceRowUpdateCommandPayload {
   rowId: string;
   changes: CircuitDeviceRowUpdateFieldChange[];
+  circuitDisplayNames?: CircuitDisplayNameTransition[];
 }
 
 export interface CircuitDeviceRowUpdateProjectCommand
@@ -50,7 +54,8 @@ export interface CircuitDeviceRowUpdateProjectCommand
 
 export function createCircuitDeviceRowUpdateProjectCommand(
   rowId: string,
-  patch: CircuitDeviceRowUpdatePatch
+  patch: CircuitDeviceRowUpdatePatch,
+  circuitDisplayNames?: CircuitDisplayNameTransition[]
 ): CircuitDeviceRowUpdateProjectCommand {
   const normalizedPatch =
     patch.quantity !== undefined && patch.manualQuantity === undefined
@@ -70,7 +75,9 @@ export function createCircuitDeviceRowUpdateProjectCommand(
   const command: CircuitDeviceRowUpdateProjectCommand = {
     schemaVersion: circuitDeviceRowUpdateCommandSchemaVersion,
     type: circuitDeviceRowUpdateCommandType,
-    payload: { rowId, changes },
+    payload: circuitDisplayNames?.length
+      ? { rowId, changes, circuitDisplayNames }
+      : { rowId, changes },
   };
   assertCircuitDeviceRowUpdateProjectCommand(command);
   return command;

src/domain/models/circuit-device-row-structure-project-command.model.ts

@@ -1,4 +1,9 @@
 import type { SerializedProjectCommand } from "./project-command.model.js";
+import {
+  assertCircuitDisplayNameTransitions,
+  withCircuitDisplayNames,
+  type CircuitDisplayNameTransition,
+} from "./circuit-display-name-sync.model.js";
 import type { ExternalModelObjectSnapshot } from "../../external-model/domain/external-model-contracts.js";
 import { parseExternalModelStateSnapshot } from "./project-state-snapshot.model.js";
 
@@ -40,12 +45,14 @@ export interface CircuitDeviceRowSnapshot {
 export interface CircuitDeviceRowInsertCommandPayload {
   row: CircuitDeviceRowSnapshot;
   externalObjects?: ExternalObjectLinkSnapshotTransition[];
+  circuitDisplayNames?: CircuitDisplayNameTransition[];
 }
 
 export interface CircuitDeviceRowDeleteCommandPayload {
   rowId: string;
   expectedCircuitId: string;
   externalObjects?: ExternalObjectLinkSnapshotTransition[];
+  circuitDisplayNames?: CircuitDisplayNameTransition[];
 }
 
 export interface CircuitDeviceRowInsertProjectCommand
@@ -66,7 +73,8 @@ export type CircuitDeviceRowStructureProjectCommand =
 
 export function createCircuitDeviceRowInsertProjectCommand(
   row: CircuitDeviceRowSnapshot,
-  externalObjects?: ExternalObjectLinkSnapshotTransition[]
+  externalObjects?: ExternalObjectLinkSnapshotTransition[],
+  circuitDisplayNames?: CircuitDisplayNameTransition[]
 ): CircuitDeviceRowInsertProjectCommand {
   const normalizedRow = {
     ...row,
@@ -75,7 +83,10 @@ export function createCircuitDeviceRowInsertProjectCommand(
   const command: CircuitDeviceRowInsertProjectCommand = {
     schemaVersion: circuitDeviceRowStructureCommandSchemaVersion,
     type: circuitDeviceRowInsertCommandType,
-    payload: { row: normalizedRow, ...(externalObjects?.length ? { externalObjects } : {}) },
+    payload: withCircuitDisplayNames(
+      { row: normalizedRow, ...(externalObjects?.length ? { externalObjects } : {}) },
+      circuitDisplayNames
+    ),
   };
   assertCircuitDeviceRowInsertProjectCommand(command);
   return command;
@@ -84,12 +95,16 @@ export function createCircuitDeviceRowInsertProjectCommand(
 export function createCircuitDeviceRowDeleteProjectCommand(
   rowId: string,
   expectedCircuitId: string,
-  externalObjects?: ExternalObjectLinkSnapshotTransition[]
+  externalObjects?: ExternalObjectLinkSnapshotTransition[],
+  circuitDisplayNames?: CircuitDisplayNameTransition[]
 ): CircuitDeviceRowDeleteProjectCommand {
   const command: CircuitDeviceRowDeleteProjectCommand = {
     schemaVersion: circuitDeviceRowStructureCommandSchemaVersion,
     type: circuitDeviceRowDeleteCommandType,
-    payload: { rowId, expectedCircuitId, ...(externalObjects?.length ? { externalObjects } : {}) },
+    payload: withCircuitDisplayNames(
+      { rowId, expectedCircuitId, ...(externalObjects?.length ? { externalObjects } : {}) },
+      circuitDisplayNames
+    ),
   };
   assertCircuitDeviceRowDeleteProjectCommand(command);
   return command;
@@ -155,6 +170,7 @@ export function assertCircuitDeviceRowInsertProjectCommand(
     }
   }
   assertExternalObjectLinkTransitions(command.payload.externalObjects);
+  assertCircuitDisplayNameTransitions(command.payload.circuitDisplayNames);
 }
 
 export function assertCircuitDeviceRowDeleteProjectCommand(
@@ -176,6 +192,7 @@ export function assertCircuitDeviceRowDeleteProjectCommand(
     "expectedCircuitId"
   );
   assertExternalObjectLinkTransitions(command.payload.externalObjects);
+  assertCircuitDisplayNameTransitions(command.payload.circuitDisplayNames);
 }
 
 export function assertExternalObjectLinkTransitions(value: unknown) {

src/domain/models/circuit-display-name-sync.model.ts

@@ -0,0 +1,99 @@
+/**
+ * A circuit with exactly one device row and no fed distribution board is
+ * shown as one compact row, so its own name is not visible or editable there.
+ * Its name therefore always follows that device row's name. Commands that
+ * change this state store the resulting circuit-name changes, so Undo/Redo
+ * restore them exactly, including a free name that was overwritten when only
+ * one device row remained.
+ */
+export interface CircuitDisplayNameTransition {
+  circuitId: string;
+  expected: string | null;
+  target: string | null;
+}
+
+/**
+ * Returns the name a circuit must carry, or `null` when its current name is
+ * already correct or freely editable.
+ */
+export function resolveSingleDeviceCircuitDisplayName(input: {
+  displayName: string | null;
+  deviceRowDisplayNames: readonly string[];
+  feedsDistributionBoard: boolean;
+}): string | null {
+  if (
+    input.deviceRowDisplayNames.length !== 1 ||
+    input.feedsDistributionBoard
+  ) {
+    return null;
+  }
+  const deviceRowDisplayName = input.deviceRowDisplayNames[0]!;
+  return input.displayName === deviceRowDisplayName
+    ? null
+    : deviceRowDisplayName;
+}
+
+export function invertCircuitDisplayNameTransitions(
+  transitions: readonly CircuitDisplayNameTransition[]
+): CircuitDisplayNameTransition[] {
+  return [...transitions].reverse().map((transition) => ({
+    circuitId: transition.circuitId,
+    expected: transition.target,
+    target: transition.expected,
+  }));
+}
+
+/** Sets the optional payload field only when it carries changes. */
+export function withCircuitDisplayNames<Payload extends object>(
+  payload: Payload,
+  circuitDisplayNames: readonly CircuitDisplayNameTransition[] | undefined
+): Payload & { circuitDisplayNames?: CircuitDisplayNameTransition[] } {
+  const { circuitDisplayNames: _previous, ...rest } = payload as Payload & {
+    circuitDisplayNames?: unknown;
+  };
+  return (
+    circuitDisplayNames?.length
+      ? { ...rest, circuitDisplayNames: [...circuitDisplayNames] }
+      : rest
+  ) as Payload & { circuitDisplayNames?: CircuitDisplayNameTransition[] };
+}
+
+export function assertCircuitDisplayNameTransitions(
+  value: unknown
+): asserts value is CircuitDisplayNameTransition[] | undefined {
+  if (value === undefined) return;
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("circuitDisplayNames must be a non-empty array.");
+  }
+  const circuitIds = new Set<string>();
+  for (const transition of value) {
+    if (
+      transition === null ||
+      typeof transition !== "object" ||
+      Array.isArray(transition)
+    ) {
+      throw new Error("Invalid circuit display-name transition.");
+    }
+    const { circuitId, expected, target } = transition as Record<
+      string,
+      unknown
+    >;
+    if (
+      typeof circuitId !== "string" ||
+      !circuitId.trim() ||
+      circuitIds.has(circuitId)
+    ) {
+      throw new Error(
+        "Circuit display-name transition has an invalid or duplicate circuit id."
+      );
+    }
+    if (
+      (expected !== null && typeof expected !== "string") ||
+      (target !== null && typeof target !== "string") ||
+      expected === target
+    ) {
+      throw new Error("Invalid circuit display-name transition values.");
+    }
+    circuitIds.add(circuitId);
+  }
+}

src/domain/models/distribution-board-project-command.model.ts

@@ -5,6 +5,11 @@ import {
   type DistributionBoardInfoField,
   type DistributionBoardSupplyType,
 } from "../../shared/constants/distribution-board.js";
+import {
+  assertCircuitDisplayNameTransitions,
+  withCircuitDisplayNames,
+  type CircuitDisplayNameTransition,
+} from "./circuit-display-name-sync.model.js";
 import type { SerializedProjectCommand } from "./project-command.model.js";
 
 export const distributionBoardUpdateCommandType =
@@ -39,6 +44,8 @@ export interface DistributionBoardUpdateFieldChange<
 export interface DistributionBoardUpdateCommandPayload {
   distributionBoardId: string;
   changes: DistributionBoardUpdateFieldChange[];
+  // Single-device feeding circuits that become compact rows take their row name.
+  circuitDisplayNames?: CircuitDisplayNameTransition[];
 }
 
 export interface DistributionBoardUpdateProjectCommand
@@ -53,18 +60,22 @@ export function createDistributionBoardUpdateProjectCommand(
   distributionBoardId: string,
   patch: DistributionBoardUpdatePatch,
   schemaVersion: DistributionBoardUpdateProjectCommand["schemaVersion"] =
-    distributionBoardUpdateCommandSchemaVersion
+    distributionBoardUpdateCommandSchemaVersion,
+  circuitDisplayNames?: CircuitDisplayNameTransition[]
 ): DistributionBoardUpdateProjectCommand {
   const command: DistributionBoardUpdateProjectCommand = {
     schemaVersion,
     type: distributionBoardUpdateCommandType,
-    payload: {
-      distributionBoardId,
-      changes: Object.entries(patch).map(([field, value]) => ({
-        field: field as DistributionBoardUpdateField,
-        value,
-      })) as DistributionBoardUpdateFieldChange[],
-    },
+    payload: withCircuitDisplayNames(
+      {
+        distributionBoardId,
+        changes: Object.entries(patch).map(([field, value]) => ({
+          field: field as DistributionBoardUpdateField,
+          value,
+        })) as DistributionBoardUpdateFieldChange[],
+      },
+      circuitDisplayNames
+    ),
   };
   assertDistributionBoardUpdateProjectCommand(command);
   return command;
@@ -154,6 +165,7 @@ export function assertDistributionBoardUpdateProjectCommand(
     }
     seen.add(change.field);
   }
+  assertCircuitDisplayNameTransitions(command.payload.circuitDisplayNames);
 }
 
 function isInfoField(field: string): field is DistributionBoardInfoField {

src/domain/models/external-object-new-row-project-command.model.ts

@@ -5,6 +5,12 @@ import {
   circuitDeviceRowStructureCommandSchemaVersion,
   type CircuitDeviceRowSnapshot,
 } from "./circuit-device-row-structure-project-command.model.js";
+import {
+  assertCircuitDisplayNameTransitions,
+  invertCircuitDisplayNameTransitions,
+  withCircuitDisplayNames,
+  type CircuitDisplayNameTransition,
+} from "./circuit-display-name-sync.model.js";
 import type { SerializedProjectCommand } from "./project-command.model.js";
 import { parseExternalModelStateSnapshot } from "./project-state-snapshot.model.js";
 
@@ -21,6 +27,7 @@ export interface ExternalObjectNewRowPayload {
     target: ExternalModelObjectSnapshot;
   }>;
   confirmedConflictObjectIds: string[];
+  circuitDisplayNames?: CircuitDisplayNameTransition[];
 }
 
 export interface ExternalObjectNewRowProjectCommand
@@ -38,14 +45,17 @@ export function createExternalObjectNewRowProjectCommand(
   const command: ExternalObjectNewRowProjectCommand = {
     schemaVersion: externalObjectNewRowCommandSchemaVersion,
     type,
-    payload: {
-      row: {
-        ...payload.row,
-        manualQuantity: payload.row.manualQuantity ?? payload.row.quantity,
+    payload: withCircuitDisplayNames(
+      {
+        row: {
+          ...payload.row,
+          manualQuantity: payload.row.manualQuantity ?? payload.row.quantity,
+        },
+        objects: payload.objects,
+        confirmedConflictObjectIds: [...payload.confirmedConflictObjectIds],
       },
-      objects: payload.objects,
-      confirmedConflictObjectIds: [...payload.confirmedConflictObjectIds],
-    },
+      payload.circuitDisplayNames
+    ),
   };
   assertExternalObjectNewRowProjectCommand(command);
   return command;
@@ -65,6 +75,9 @@ export function invertExternalObjectNewRowProjectCommand(
         target: expected,
       })),
       confirmedConflictObjectIds: command.payload.confirmedConflictObjectIds,
+      circuitDisplayNames: invertCircuitDisplayNameTransitions(
+        command.payload.circuitDisplayNames ?? []
+      ),
     }
   );
 }
@@ -112,6 +125,7 @@ export function assertExternalObjectNewRowProjectCommand(
     }
     confirmedIds.add(objectId);
   }
+  assertCircuitDisplayNameTransitions(command.payload.circuitDisplayNames);
 }
 
 function parseRow(value: unknown): CircuitDeviceRowSnapshot {

src/domain/models/project-device-row-sync-project-command.model.ts

@@ -5,6 +5,11 @@ import {
   type CircuitDeviceRowUpdateField,
   type CircuitDeviceRowUpdateValues,
 } from "./circuit-device-row-project-command.model.js";
+import {
+  assertCircuitDisplayNameTransitions,
+  withCircuitDisplayNames,
+  type CircuitDisplayNameTransition,
+} from "./circuit-display-name-sync.model.js";
 import type { SerializedProjectCommand } from "./project-command.model.js";
 
 export const projectDeviceRowSyncCommandType =
@@ -47,6 +52,7 @@ export interface ProjectDeviceRowSyncCommandPayload {
   projectDeviceId: string;
   operation: ProjectDeviceRowSyncOperation;
   rows: ProjectDeviceRowSyncAssignment[];
+  circuitDisplayNames?: CircuitDisplayNameTransition[];
 }
 
 export interface ProjectDeviceRowSyncProjectCommand
@@ -58,12 +64,16 @@ export interface ProjectDeviceRowSyncProjectCommand
 export function createProjectDeviceRowSyncProjectCommand(
   projectDeviceId: string,
   operation: ProjectDeviceRowSyncOperation,
-  rows: ProjectDeviceRowSyncAssignment[]
+  rows: ProjectDeviceRowSyncAssignment[],
+  circuitDisplayNames?: CircuitDisplayNameTransition[]
 ): ProjectDeviceRowSyncProjectCommand {
   const command: ProjectDeviceRowSyncProjectCommand = {
     schemaVersion: projectDeviceRowSyncCommandSchemaVersion,
     type: projectDeviceRowSyncCommandType,
-    payload: { projectDeviceId, operation, rows },
+    payload: withCircuitDisplayNames(
+      { projectDeviceId, operation, rows },
+      circuitDisplayNames
+    ),
   };
   assertProjectDeviceRowSyncProjectCommand(command);
   return command;
@@ -131,6 +141,7 @@ export function assertProjectDeviceRowSyncProjectCommand(
     );
     rowIds.add(row.rowId);
   }
+  assertCircuitDisplayNameTransitions(command.payload.circuitDisplayNames);
 }
 
 export function invertProjectDeviceRowSyncOperation(