Add Revit return workbook export

docs/spec/revit-excel-integration-requirements.md

@@ -306,6 +306,16 @@ aktuellen Row-Werte als Planungswerte und entsprechende Overrides.
 
 ## 11. Editor-Zuordnung und Löschen
 
+Umsetzungsstand R7: Der Stromkreislisteneditor lädt die kompakte Projektliste
+gemeinsam mit dem Baum, gruppiert unzugeordnete Objekte des aktuellen
+Verteilers im Client und bietet Gruppen sowie einzelne Worksharing-IDs als
+Drag-Quelle an. Drop auf Row, Circuit und freien Gruppenbereich verwendet die
+drei persistenten Zuordnungscommands. Row-Badges zeigen die Linkzahl; Lösen
+kopiert die aktuellen Row-Planungswerte als Overrides. Row-, Circuit- und
+Gruppenlöschungen speichern die vollständigen Linkübergänge im Forward- und
+Inverse-Command. Raum- und Verteilerlöschungen prüfen externe Referenzen
+explizit.
+
 Der rechte, überlagernde Editorbereich zeigt unzugeordnete konfliktfreie
 Objekte des aktuellen Verteilers. Gruppierungsschlüssel sind interner Raum,
 Auswahlkenner, Geräteart, Kategorie, identische Planungswerte und kompatibler
@@ -338,6 +348,14 @@ Pfade.
 
 ## 12. Rückgabe-Excel
 
+Umsetzungsstand R8: Die Revit-Objekttabelle bietet alle drei Rückgabeumfänge
+an und lädt eine aus dem letzten vollständigen Import erzeugte XLSX herunter.
+Die Serverprojektion verwendet für verknüpfte Objekte die aktuellen Row- und
+Circuit-Werte, für freie Objekte die Planungswerte und schreibt Zahlen als
+Excel-Zahlen. Hinweise zu nicht berechenbaren Werten und fehlenden optionalen
+Spalten werden nach dem Download angezeigt. Der append-only Exportnachweis
+liegt außerhalb von Projektrevision, Undo/Redo, Snapshots und Transfer.
+
 Der Export ist eine Leseoperation ohne Projektrevision. Ein append-only
 Nachweis speichert Projektrevision, zugrunde liegenden letzten Import,
 Zeitpunkt, Dateiname, SHA-256, Konfigurationskopie beziehungsweise ihren Hash

docs/spec/revit-excel-phase-14-plan.md

@@ -15,8 +15,8 @@ Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
 | R4 | abgeschlossen | Revit-Seite, Navigation und revisionierte XLSX-Einstellungen mit Musterdateiprüfung sind umgesetzt; das alte Projektseitenmodal ist entfernt. |
 | R5 | abgeschlossen | Zustandslose XLSX-Vorschau, sechsstufiger Erstimportwizard und atomarer Importcommand mit parserfreiem Undo/Redo. |
 | R6 | abgeschlossen | Projektweite kompakte Objektliste, clientseitige Filter/Sortierung, Virtualisierung und revisionierte Sammeländerungen. |
-| R7 | offen | Editorbereich, Gruppierung, Drag-and-drop, Lösen und integrierte Löschübergänge. |
-| R8 | offen | Rückgabe-Excel und append-only Exportnachweis. |
+| R7 | abgeschlossen | Gruppierter Editorbereich, drei Drag-and-drop-Ziele, Row-Indikator, ausdrückliches Lösen und atomare Löschübergänge mit exaktem Undo/Redo. |
+| R8 | abgeschlossen | Rückgabe-Excel für alle, abweichende oder ausgewählte Objekte und append-only Exportnachweis sind umgesetzt. |
 | R9 | offen | Vollständiger Folgeimport nach Worksharing-ID. |
 | R10 | offen | Ende-zu-Ende-Härtung, große Datenmengen und Abschlussdokumentation. |
 
@@ -173,6 +173,13 @@ Sammelaktionen gesperrt und folgen weiterhin ausschließlich ihrer Row.
 
 R8 baut auf der in R2 durch Linear bestätigten Transportstrategie auf.
 
+Umsetzungsstand: Die Revit-Objekttabelle erzeugt die Rückgabe revisionssicher
+aus dem letzten vollständigen Import. Die gemeinsame Projektion berechnet
+Stromkreis, Bezeichnung, Leistung, Spannung und Strom; der XLSX-Adapter erhält
+Struktur und Formate und meldet fehlende optionale Spalten. Jeder erfolgreiche
+Download wird außerhalb von Projektcommands, Snapshots und Transfers mit
+Revision, Importbatch, Konfigurationskopie und Prüfsummen protokolliert.
+
 ## R9 – Folgeimport
 
 - exaktes, case-sensitives Matching nach Worksharing-ID;

src/app/globals.css

@@ -1128,6 +1128,17 @@ a.kpi:hover {
   border-style: dashed;
 }
 
+.project-device-item > summary {
+  display: flex;
+  flex-direction: column;
+  gap: 0.1rem;
+  cursor: grab;
+}
+
+.project-device-item > summary::marker {
+  color: var(--text-faint);
+}
+
 .sidebar-actions {
   display: flex;
   flex-direction: column;

src/app/projects/[projectId]/revit/page.tsx

@@ -45,7 +45,7 @@ export default function RevitPage() {
     {error ? <div className="alert alert-danger">{error}</div> : null}
     <div className="row g-3 mt-1"><div className="col-md-6"><section className="card h-100"><div className="card-body"><FileSpreadsheet className="mb-3" size={28} /><h2 className="h5">XLSX-Konfiguration</h2><p className="text-secondary">{snapshot ? "Die Linear-Spalten und das Tabellenlayout sind konfiguriert." : "Noch keine XLSX-Konfiguration gespeichert."}</p><span className={`badge ${snapshot ? "text-bg-success" : "text-bg-secondary"}`}>{snapshot ? "Konfiguriert" : "Offen"}</span></div></section></div><div className="col-md-6"><section className="card h-100"><div className="card-body"><h2 className="h5">Importstatus</h2>{importStatus?.imported ? <><p className="mb-1"><strong>{importStatus.objectCount} Revit-Objekte</strong>{importStatus.fileName ? ` aus ${importStatus.fileName}` : ""}</p><p className="text-secondary mb-0">Quelle: {importStatus.sourceName}</p></> : <p className="text-secondary mb-0">Noch kein Linear-XLSX-Import vorhanden.</p>}</div></section></div></div>
     {importStatus?.imported ? <RevitObjectTable projectId={projectId} onRevision={(revision) => setProject((current) => current ? { ...current, currentRevision: revision } : current)} /> : null}
-    {settingsOpen ? <RevitXlsxSettingsModal configuration={snapshot?.configuration ?? createDefaultRevitXlsxConfiguration()} isSaving={saving} onClose={() => setSettingsOpen(false)} onInspectSample={async (file, configuration) => { const result = await detectExternalModelWorkbook(projectId, file, configuration); return `Muster erkannt: ${result.sheetName}, ${result.columnCount} Spalten, ${result.objectCount} Objekte.`; }} onSave={save} /> : null}
+    {settingsOpen ? <RevitXlsxSettingsModal configuration={snapshot?.configuration ?? createDefaultRevitXlsxConfiguration()} isNewConfiguration={snapshot === null} isSaving={saving} onClose={() => setSettingsOpen(false)} onInspectSample={async (file, configuration) => { const result = await detectExternalModelWorkbook(projectId, file, configuration); return `Muster erkannt: ${result.sheetName}, ${result.columnCount} Spalten, ${result.objectCount} Objekte.`; }} onSave={save} /> : null}
     {importOpen && project && snapshot ? <RevitInitialImportWizard projectId={projectId} expectedRevision={project.currentRevision} initialConfiguration={snapshot.configuration} onClose={() => setImportOpen(false)} onImported={({ history }) => { setProject({ ...project, currentRevision: history.currentRevision }); setImportOpen(false); void Promise.all([getExternalInitialImportStatus(projectId), getExternalModelConfiguration(projectId)]).then(([status, configuration]) => { setImportStatus(status); setSnapshot(configuration.configuration); }); }} /> : null}
   </main>;
 }

src/db/migrations/0015_wide_night_thrasher.sql

@@ -0,0 +1,16 @@
+CREATE TABLE `external_export_batches` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`project_revision` integer NOT NULL,
+	`import_batch_id` text NOT NULL,
+	`exported_at_iso` text NOT NULL,
+	`file_name` text NOT NULL,
+	`sha256` text NOT NULL,
+	`configuration_snapshot` text NOT NULL,
+	`configuration_sha256` text NOT NULL,
+	`scope` text NOT NULL,
+	`object_count` integer NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX `external_export_batches_project_exported_idx` ON `external_export_batches` (`project_id`,`exported_at_iso`);

src/db/migrations/meta/_journal.json

@@ -106,6 +106,13 @@
       "when": 1790748107566,
       "tag": "0014_linear_xlsx_external_model",
       "breakpoints": true
+    },
+    {
+      "idx": 15,
+      "version": "6",
+      "when": 1790773066696,
+      "tag": "0015_wide_night_thrasher",
+      "breakpoints": true
     }
   ]
 }

src/db/repositories/circuit-device-row-structure-project-command.repository.ts

@@ -23,8 +23,15 @@ import {
   toCircuitDeviceRowInsertValues,
   toCircuitDeviceRowSnapshot,
 } from "./circuit-device-row-structure.persistence.js";
-import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { executeProjectCommandTransactionWithAppliedForward, type AppliedProjectCommand } from "./project-command-transaction.persistence.js";
 import { updateDerivedCircuitVoltage } from "./project-voltage.persistence.js";
+import {
+  applyExternalObjectLinks,
+  captureExternalObjectDetachTransitions,
+  invertExternalObjectLinkTransitions,
+  loadExpectedExternalObjectTransitions,
+  type ExternalObjectLinkTransition,
+} from "./external-object-assignment.persistence.js";
 
 export class CircuitDeviceRowStructureProjectCommandRepository
   implements CircuitDeviceRowStructureProjectCommandStore
@@ -32,7 +39,11 @@ export class CircuitDeviceRowStructureProjectCommandRepository
   constructor(private readonly database: AppDatabase) {}
 
   execute(input: ExecuteCircuitDeviceRowStructureCommandInput) {
-    return executeProjectCommandTransaction(
+    return executeProjectCommandTransactionWithAppliedForward<
+      CircuitDeviceRowStructureProjectCommand,
+      CircuitDeviceRowStructureProjectCommand,
+      CircuitDeviceRowStructureProjectCommand
+    >(
       this.database,
       input,
       (tx) =>
@@ -50,14 +61,15 @@ export class CircuitDeviceRowStructureProjectCommandRepository
     projectId: string,
     source: ExecuteCircuitDeviceRowStructureCommandInput["source"],
     command: CircuitDeviceRowStructureProjectCommand
-  ): CircuitDeviceRowStructureProjectCommand {
+  ): AppliedProjectCommand<CircuitDeviceRowStructureProjectCommand, CircuitDeviceRowStructureProjectCommand> {
     if (command.type === circuitDeviceRowInsertCommandType) {
       assertCircuitDeviceRowInsertProjectCommand(command);
       return this.insert(
         database,
         projectId,
         source,
-        command.payload.row
+        command.payload.row,
+        command.payload.externalObjects ?? []
       );
     }
     if (command.type === circuitDeviceRowDeleteCommandType) {
@@ -66,7 +78,8 @@ export class CircuitDeviceRowStructureProjectCommandRepository
         database,
         projectId,
         command.payload.rowId,
-        command.payload.expectedCircuitId
+        command.payload.expectedCircuitId,
+        command.payload.externalObjects
       );
     }
     throw new Error("Unsupported circuit device-row structure command.");
@@ -76,7 +89,8 @@ export class CircuitDeviceRowStructureProjectCommandRepository
     database: AppDatabase,
     projectId: string,
     source: ExecuteCircuitDeviceRowStructureCommandInput["source"],
-    row: CircuitDeviceRowSnapshot
+    row: CircuitDeviceRowSnapshot,
+    externalObjects: ExternalObjectLinkTransition[]
   ) {
     if (source === "user" && !isElectricalPhaseType(row.phaseType)) {
       throw new Error("Device-row phase type is invalid.");
@@ -107,17 +121,23 @@ export class CircuitDeviceRowStructureProjectCommandRepository
     }
     updateDerivedCircuitVoltage(database, projectId, row.circuitId);
 
-    return createCircuitDeviceRowDeleteProjectCommand(
-      row.id,
-      row.circuitId
-    );
+    if (externalObjects.length > 0) {
+      loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Wiederherstellen geändert.");
+      applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Wiederherstellen geändert.");
+    }
+
+    return {
+      forward: createCircuitDeviceRowInsertProjectCommand(row, externalObjects),
+      inverse: createCircuitDeviceRowDeleteProjectCommand(row.id, row.circuitId, invertExternalObjectLinkTransitions(externalObjects)),
+    };
   }
 
   private delete(
     database: AppDatabase,
     projectId: string,
     rowId: string,
-    expectedCircuitId: string
+    expectedCircuitId: string,
+    suppliedExternalObjects?: ExternalObjectLinkTransition[]
   ) {
     const row = database
       .select()
@@ -130,6 +150,10 @@ export class CircuitDeviceRowStructureProjectCommandRepository
       );
     }
     this.assertCircuitInProject(database, projectId, row.circuitId);
+    const externalObjects = suppliedExternalObjects ??
+      captureExternalObjectDetachTransitions(database, projectId, [rowId]);
+    loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Löschen geändert.");
+    applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Löschen geändert.");
 
     const result = database
       .delete(circuitDeviceRows)
@@ -164,9 +188,10 @@ export class CircuitDeviceRowStructureProjectCommandRepository
       expectedCircuitId
     );
 
-    return createCircuitDeviceRowInsertProjectCommand(
-      toCircuitDeviceRowSnapshot(row)
-    );
+    return {
+      forward: createCircuitDeviceRowDeleteProjectCommand(rowId, expectedCircuitId, externalObjects),
+      inverse: createCircuitDeviceRowInsertProjectCommand(toCircuitDeviceRowSnapshot(row), invertExternalObjectLinkTransitions(externalObjects)),
+    };
   }
 
   private assertCircuitInProject(

src/db/repositories/circuit-group-subtree-project-command.repository.ts

@@ -25,8 +25,14 @@ import { circuits } from "../schema/circuits.js";
 import { distributionBoardComponentProtectionDevices } from "../schema/distribution-board-component-protection-devices.js";
 import { distributionBoardComponents } from "../schema/distribution-board-components.js";
 import { toCircuitDeviceRowInsertValues } from "./circuit-device-row-structure.persistence.js";
-import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { executeProjectCommandTransactionWithAppliedForward, type AppliedProjectCommand } from "./project-command-transaction.persistence.js";
 import { assertCircuitsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
+import {
+  applyExternalObjectLinks,
+  captureExternalObjectDetachTransitions,
+  invertExternalObjectLinkTransitions,
+  loadExpectedExternalObjectTransitions,
+} from "./external-object-assignment.persistence.js";
 
 export class CircuitGroupSubtreeProjectCommandRepository
   implements CircuitGroupSubtreeProjectCommandStore
@@ -43,7 +49,11 @@ export class CircuitGroupSubtreeProjectCommandRepository
     } else {
       assertCircuitGroupRestoreSubtreeProjectCommand(input.command);
     }
-    return executeProjectCommandTransaction(
+    return executeProjectCommandTransactionWithAppliedForward<
+      CircuitGroupSubtreeProjectCommand,
+      CircuitGroupSubtreeProjectCommand,
+      CircuitGroupSubtreeProjectCommand
+    >(
       this.database,
       input,
       (tx) => this.applyCommand(tx, input.projectId, input.command)
@@ -54,7 +64,7 @@ export class CircuitGroupSubtreeProjectCommandRepository
     database: AppDatabase,
     projectId: string,
     command: CircuitGroupSubtreeProjectCommand
-  ) {
+  ): AppliedProjectCommand<CircuitGroupSubtreeProjectCommand, CircuitGroupSubtreeProjectCommand> {
     if (command.type === circuitGroupDeleteSubtreeCommandType) {
       const current = this.captureFrom(
         database,
@@ -71,6 +81,14 @@ export class CircuitGroupSubtreeProjectCommandRepository
         projectId,
         current.circuits.map((entry) => entry.circuit.id)
       );
+      const externalObjects = command.payload.externalObjects ??
+        captureExternalObjectDetachTransitions(
+          database,
+          projectId,
+          current.circuits.flatMap((entry) => entry.circuit.deviceRows.map((row) => row.id))
+        );
+      loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Löschen geändert.");
+      applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Löschen geändert.");
       const deleted = database
         .delete(circuitSections)
         .where(eq(circuitSections.id, current.group.id))
@@ -78,15 +96,20 @@ export class CircuitGroupSubtreeProjectCommandRepository
       if (deleted.changes !== 1) {
         throw new Error("Circuit-group subtree could not be deleted.");
       }
-      return createCircuitGroupRestoreSubtreeProjectCommand(
-        command.payload.snapshot
-      );
+      return {
+        forward: createCircuitGroupDeleteSubtreeProjectCommand(command.payload.snapshot, externalObjects),
+        inverse: createCircuitGroupRestoreSubtreeProjectCommand(command.payload.snapshot, invertExternalObjectLinkTransitions(externalObjects)),
+      };
     }
     if (command.type === circuitGroupRestoreSubtreeCommandType) {
       this.restore(database, projectId, command.payload.snapshot);
-      return createCircuitGroupDeleteSubtreeProjectCommand(
-        command.payload.snapshot
-      );
+      const externalObjects = command.payload.externalObjects ?? [];
+      loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Wiederherstellen geändert.");
+      applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Wiederherstellen geändert.");
+      return {
+        forward: createCircuitGroupRestoreSubtreeProjectCommand(command.payload.snapshot, externalObjects),
+        inverse: createCircuitGroupDeleteSubtreeProjectCommand(command.payload.snapshot, invertExternalObjectLinkTransitions(externalObjects)),
+      };
     }
     throw new Error("Unsupported circuit-group subtree command.");
   }

src/db/repositories/circuit-structure-project-command.repository.ts

@@ -25,10 +25,17 @@ import {
   toCircuitDeviceRowInsertValues,
   toCircuitDeviceRowSnapshot,
 } from "./circuit-device-row-structure.persistence.js";
-import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { executeProjectCommandTransactionWithAppliedForward, type AppliedProjectCommand } from "./project-command-transaction.persistence.js";
 import { assertCircuitsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
 import { resolveCircuitVoltage } from "./project-voltage.persistence.js";
 import { assertEquipmentIdentifierAvailable } from "./equipment-identifier-uniqueness.persistence.js";
+import {
+  applyExternalObjectLinks,
+  captureExternalObjectDetachTransitions,
+  invertExternalObjectLinkTransitions,
+  loadExpectedExternalObjectTransitions,
+  type ExternalObjectLinkTransition,
+} from "./external-object-assignment.persistence.js";
 
 export class CircuitStructureProjectCommandRepository
   implements CircuitStructureProjectCommandStore
@@ -36,11 +43,15 @@ export class CircuitStructureProjectCommandRepository
   constructor(private readonly database: AppDatabase) {}
 
   execute(input: ExecuteCircuitStructureCommandInput) {
-    return executeProjectCommandTransaction(
+    return executeProjectCommandTransactionWithAppliedForward<
+      CircuitStructureProjectCommand,
+      CircuitStructureProjectCommand,
+      CircuitStructureProjectCommand
+    >(
       this.database,
       input,
       (tx) =>
-        this.applyInTransaction(
+        this.applyWithForward(
           tx,
           input.projectId,
           input.source,
@@ -59,13 +70,23 @@ export class CircuitStructureProjectCommandRepository
     source: ExecuteCircuitStructureCommandInput["source"],
     command: CircuitStructureProjectCommand
   ): CircuitStructureProjectCommand {
+    return this.applyWithForward(database, projectId, source, command).inverse;
+  }
+
+  private applyWithForward(
+    database: AppDatabase,
+    projectId: string,
+    source: ExecuteCircuitStructureCommandInput["source"],
+    command: CircuitStructureProjectCommand
+  ): AppliedProjectCommand<CircuitStructureProjectCommand, CircuitStructureProjectCommand> {
     if (command.type === circuitInsertCommandType) {
       assertCircuitInsertProjectCommand(command);
       return this.insert(
         database,
         projectId,
         source,
-        command.payload.circuit
+        command.payload.circuit,
+        command.payload.externalObjects ?? []
       );
     }
     if (command.type === circuitDeleteCommandType) {
@@ -74,7 +95,8 @@ export class CircuitStructureProjectCommandRepository
         database,
         projectId,
         command.payload.circuitId,
-        command.payload.expectedCircuitListId
+        command.payload.expectedCircuitListId,
+        command.payload.externalObjects
       );
     }
     throw new Error("Unsupported circuit structure command.");
@@ -84,7 +106,8 @@ export class CircuitStructureProjectCommandRepository
     database: AppDatabase,
     projectId: string,
     source: ExecuteCircuitStructureCommandInput["source"],
-    snapshot: CircuitSnapshot
+    snapshot: CircuitSnapshot,
+    externalObjects: ExternalObjectLinkTransition[]
   ) {
     this.assertCircuitLocation(database, projectId, snapshot);
     if (source === "user") {
@@ -172,17 +195,23 @@ export class CircuitStructureProjectCommandRepository
         .run();
     }
 
-    return createCircuitDeleteProjectCommand(
-      snapshot.id,
-      snapshot.circuitListId
-    );
+    if (externalObjects.length > 0) {
+      loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Wiederherstellen geändert.");
+      applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Wiederherstellen geändert.");
+    }
+
+    return {
+      forward: createCircuitInsertProjectCommand(snapshot, externalObjects),
+      inverse: createCircuitDeleteProjectCommand(snapshot.id, snapshot.circuitListId, invertExternalObjectLinkTransitions(externalObjects)),
+    };
   }
 
   private delete(
     database: AppDatabase,
     projectId: string,
     circuitId: string,
-    expectedCircuitListId: string
+    expectedCircuitListId: string,
+    suppliedExternalObjects?: ExternalObjectLinkTransition[]
   ) {
     const circuit = database
       .select()
@@ -220,7 +249,12 @@ export class CircuitStructureProjectCommandRepository
       .from(circuitProtectionDevices)
       .where(eq(circuitProtectionDevices.circuitId, circuit.id))
       .get();
-    const inverse = createCircuitInsertProjectCommand({
+    const externalObjects = suppliedExternalObjects ?? captureExternalObjectDetachTransitions(
+      database, projectId, rows.map((row) => row.id)
+    );
+    loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Löschen geändert.");
+    applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Löschen geändert.");
+    const circuitSnapshot: CircuitSnapshot = {
       id: circuit.id,
       circuitListId: circuit.circuitListId,
       sectionId: circuit.sectionId,
@@ -239,7 +273,7 @@ export class CircuitStructureProjectCommandRepository
       remark: circuit.remark,
       deviceRows: rows.map(toCircuitDeviceRowSnapshot),
       protectionDevice: protectionDevice ?? null,
-    });
+    };
 
     assertCircuitsAreNotReferencedAsFeeders(database, projectId, [circuit.id]);
 
@@ -255,7 +289,10 @@ export class CircuitStructureProjectCommandRepository
     if (result.changes !== 1) {
       throw new Error("Circuit could not be deleted.");
     }
-    return inverse;
+    return {
+      forward: createCircuitDeleteProjectCommand(circuitId, expectedCircuitListId, externalObjects),
+      inverse: createCircuitInsertProjectCommand(circuitSnapshot, invertExternalObjectLinkTransitions(externalObjects)),
+    };
   }
 
   private assertCircuitLocation(

src/db/repositories/distribution-board-structure-project-command.repository.ts

@@ -46,6 +46,7 @@ import { floors } from "../schema/floors.js";
 import { projects } from "../schema/projects.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
 import { assertBoardsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
+import { assertDistributionBoardHasNoExternalObjects } from "./external-object-deletion-guard.persistence.js";
 import { CircuitStructureProjectCommandRepository } from "./circuit-structure-project-command.repository.js";
 
 export class DistributionBoardStructureProjectCommandRepository
@@ -290,6 +291,7 @@ export class DistributionBoardStructureProjectCommandRepository
     }
 
     assertBoardsAreNotReferencedAsFeeders(database, projectId, [board.id]);
+    assertDistributionBoardHasNoExternalObjects(database, projectId, board.id);
 
     const deleted = database
       .delete(distributionBoards)

src/db/repositories/distribution-board-subtree-project-command.repository.ts

@@ -33,6 +33,7 @@ import { rooms } from "../schema/rooms.js";
 import { toCircuitDeviceRowInsertValues } from "./circuit-device-row-structure.persistence.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
 import { assertBoardsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
+import { assertDistributionBoardHasNoExternalObjects } from "./external-object-deletion-guard.persistence.js";
 
 export class DistributionBoardSubtreeProjectCommandRepository
   implements DistributionBoardSubtreeProjectCommandStore
@@ -86,6 +87,7 @@ export class DistributionBoardSubtreeProjectCommandRepository
       assertBoardsAreNotReferencedAsFeeders(database, projectId, [
         current.distributionBoard.id,
       ]);
+      assertDistributionBoardHasNoExternalObjects(database, projectId, current.distributionBoard.id);
       const deleted = database
         .delete(distributionBoards)
         .where(

src/db/repositories/external-export-batch.repository.ts

@@ -0,0 +1,18 @@
+import { desc, eq } from "drizzle-orm";
+import type { AppDatabase } from "../database-context.js";
+import { externalExportBatches } from "../schema/external-export-batches.js";
+
+export class ExternalExportBatchRepository {
+  constructor(private readonly database: AppDatabase) {}
+
+  append(batch: typeof externalExportBatches.$inferInsert) {
+    this.database.insert(externalExportBatches).values(batch).run();
+    return batch;
+  }
+
+  listByProject(projectId: string) {
+    return this.database.select().from(externalExportBatches)
+      .where(eq(externalExportBatches.projectId, projectId))
+      .orderBy(desc(externalExportBatches.exportedAtIso), desc(externalExportBatches.id)).all();
+  }
+}

src/db/repositories/external-object-assignment.persistence.ts

@@ -11,6 +11,27 @@ export interface ExternalObjectLinkTransition {
   target: ExternalModelObjectSnapshot;
 }
 
+export function captureExternalObjectDetachTransitions(
+  database: AppDatabase,
+  projectId: string,
+  rowIds: string[]
+): ExternalObjectLinkTransition[] {
+  if (rowIds.length === 0) return [];
+  return database.select().from(externalModelObjects)
+    .where(and(
+      eq(externalModelObjects.projectId, projectId),
+      inArray(externalModelObjects.circuitDeviceRowId, rowIds)
+    )).all()
+    .map(toExternalObjectSnapshot)
+    .map((expected) => ({ expected, target: { ...expected, circuitDeviceRowId: null } }));
+}
+
+export function invertExternalObjectLinkTransitions(
+  transitions: ExternalObjectLinkTransition[]
+): ExternalObjectLinkTransition[] {
+  return transitions.map(({ expected, target }) => ({ expected: target, target: expected }));
+}
+
 export function loadExpectedExternalObjectTransitions(
   database: AppDatabase,
   projectId: string,
@@ -86,7 +107,13 @@ export function applyExternalObjectLinks(
 ) {
   for (const { expected, target } of transitions) {
     const updated = database.update(externalModelObjects)
-      .set({ circuitDeviceRowId: target.circuitDeviceRowId })
+      .set({
+        circuitDeviceRowId: target.circuitDeviceRowId,
+        distributionBoardId: target.distributionBoardId,
+        linkedProjectDeviceId: target.linkedProjectDeviceId,
+        planningValues: target.planningValues,
+        overriddenFields: target.overriddenFields,
+      })
       .where(and(
         eq(externalModelObjects.id, expected.id),
         expected.circuitDeviceRowId === null

src/db/repositories/external-object-deletion-guard.persistence.ts

@@ -0,0 +1,37 @@
+import { and, eq } from "drizzle-orm";
+import type { AppDatabase } from "../database-context.js";
+import { externalModelObjects } from "../schema/external-model-objects.js";
+import { externalRoomMappings } from "../schema/external-room-mappings.js";
+
+export function assertDistributionBoardHasNoExternalObjects(
+  database: AppDatabase,
+  projectId: string,
+  distributionBoardId: string
+) {
+  const reference = database.select({ id: externalModelObjects.id })
+    .from(externalModelObjects)
+    .where(and(
+      eq(externalModelObjects.projectId, projectId),
+      eq(externalModelObjects.distributionBoardId, distributionBoardId)
+    )).limit(1).get();
+  if (reference) {
+    throw new Error("Der Verteiler kann nicht gelöscht werden, solange Revit-Objekte auf ihn verweisen.");
+  }
+}
+
+export function assertRoomHasNoExternalObjects(
+  database: AppDatabase,
+  projectId: string,
+  roomId: string
+) {
+  const reference = database.select({ id: externalModelObjects.id })
+    .from(externalModelObjects)
+    .innerJoin(externalRoomMappings, eq(externalRoomMappings.id, externalModelObjects.externalRoomMappingId))
+    .where(and(
+      eq(externalModelObjects.projectId, projectId),
+      eq(externalRoomMappings.roomId, roomId)
+    )).limit(1).get();
+  if (reference) {
+    throw new Error("Der Raum kann nicht gelöscht werden, solange Revit-Objekte auf ihn verweisen.");
+  }
+}

src/db/repositories/project-location-structure-project-command.repository.ts

@@ -46,6 +46,7 @@ import { distributionBoards } from "../schema/distribution-boards.js";
 import { projects } from "../schema/projects.js";
 import { rooms } from "../schema/rooms.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { assertRoomHasNoExternalObjects } from "./external-object-deletion-guard.persistence.js";
 
 export class ProjectLocationStructureProjectCommandRepository
   implements ProjectLocationStructureProjectCommandStore
@@ -439,6 +440,7 @@ export class ProjectLocationStructureProjectCommandRepository
         "Der Raum kann nicht gelöscht werden, solange er in einem Stromkreis verwendet wird."
       );
     }
+    assertRoomHasNoExternalObjects(database, projectId, expected.id);
     const deleted = database
       .delete(rooms)
       .where(

src/db/schema/external-export-batches.ts

@@ -0,0 +1,24 @@
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
+import { projects } from "./projects.js";
+
+export const externalExportScopes = ["all", "deviating", "selected"] as const;
+export type ExternalExportScope = (typeof externalExportScopes)[number];
+
+export const externalExportBatches = sqliteTable(
+  "external_export_batches",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    projectRevision: integer("project_revision").notNull(),
+    importBatchId: text("import_batch_id").notNull(),
+    exportedAtIso: text("exported_at_iso").notNull(),
+    fileName: text("file_name").notNull(),
+    sha256: text("sha256").notNull(),
+    configurationSnapshot: text("configuration_snapshot", { mode: "json" }).$type<ExternalModelConfiguration>().notNull(),
+    configurationSha256: text("configuration_sha256").notNull(),
+    scope: text("scope", { enum: externalExportScopes }).notNull(),
+    objectCount: integer("object_count").notNull(),
+  },
+  (table) => [index("external_export_batches_project_exported_idx").on(table.projectId, table.exportedAtIso)]
+);

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

@@ -1,4 +1,11 @@
 import type { SerializedProjectCommand } from "./project-command.model.js";
+import type { ExternalModelObjectSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import { parseExternalModelStateSnapshot } from "./project-state-snapshot.model.js";
+
+export interface ExternalObjectLinkSnapshotTransition {
+  expected: ExternalModelObjectSnapshot;
+  target: ExternalModelObjectSnapshot;
+}
 
 export const circuitDeviceRowInsertCommandType =
   "circuit-device-row.insert" as const;
@@ -32,11 +39,13 @@ export interface CircuitDeviceRowSnapshot {
 
 export interface CircuitDeviceRowInsertCommandPayload {
   row: CircuitDeviceRowSnapshot;
+  externalObjects?: ExternalObjectLinkSnapshotTransition[];
 }
 
 export interface CircuitDeviceRowDeleteCommandPayload {
   rowId: string;
   expectedCircuitId: string;
+  externalObjects?: ExternalObjectLinkSnapshotTransition[];
 }
 
 export interface CircuitDeviceRowInsertProjectCommand
@@ -56,7 +65,8 @@ export type CircuitDeviceRowStructureProjectCommand =
   | CircuitDeviceRowDeleteProjectCommand;
 
 export function createCircuitDeviceRowInsertProjectCommand(
-  row: CircuitDeviceRowSnapshot
+  row: CircuitDeviceRowSnapshot,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitDeviceRowInsertProjectCommand {
   const normalizedRow = {
     ...row,
@@ -65,7 +75,7 @@ export function createCircuitDeviceRowInsertProjectCommand(
   const command: CircuitDeviceRowInsertProjectCommand = {
     schemaVersion: circuitDeviceRowStructureCommandSchemaVersion,
     type: circuitDeviceRowInsertCommandType,
-    payload: { row: normalizedRow },
+    payload: { row: normalizedRow, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitDeviceRowInsertProjectCommand(command);
   return command;
@@ -73,12 +83,13 @@ export function createCircuitDeviceRowInsertProjectCommand(
 
 export function createCircuitDeviceRowDeleteProjectCommand(
   rowId: string,
-  expectedCircuitId: string
+  expectedCircuitId: string,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitDeviceRowDeleteProjectCommand {
   const command: CircuitDeviceRowDeleteProjectCommand = {
     schemaVersion: circuitDeviceRowStructureCommandSchemaVersion,
     type: circuitDeviceRowDeleteCommandType,
-    payload: { rowId, expectedCircuitId },
+    payload: { rowId, expectedCircuitId, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitDeviceRowDeleteProjectCommand(command);
   return command;
@@ -143,6 +154,7 @@ export function assertCircuitDeviceRowInsertProjectCommand(
       throw new Error("row.cosPhi must be positive or null.");
     }
   }
+  assertExternalObjectLinkTransitions(command.payload.externalObjects);
 }
 
 export function assertCircuitDeviceRowDeleteProjectCommand(
@@ -163,6 +175,41 @@ export function assertCircuitDeviceRowDeleteProjectCommand(
     command.payload.expectedCircuitId,
     "expectedCircuitId"
   );
+  assertExternalObjectLinkTransitions(command.payload.externalObjects);
+}
+
+export function assertExternalObjectLinkTransitions(value: unknown) {
+  if (value === undefined) return;
+  if (!Array.isArray(value)) throw new Error("externalObjects must be an array.");
+  const ids = new Set<string>();
+  for (const transition of value) {
+    if (!isPlainObject(transition) || !isPlainObject(transition.expected) || !isPlainObject(transition.target)) {
+      throw new Error("Invalid external object link transition.");
+    }
+    const expectedId = transition.expected.id;
+    const targetId = transition.target.id;
+    if (typeof expectedId !== "string" || expectedId !== targetId || ids.has(expectedId)) {
+      throw new Error("External object link transition has mismatched or duplicate ids.");
+    }
+    ids.add(expectedId);
+    const expectedRowId = transition.expected.circuitDeviceRowId;
+    const targetRowId = transition.target.circuitDeviceRowId;
+    if ((expectedRowId !== null && typeof expectedRowId !== "string") || (targetRowId !== null && typeof targetRowId !== "string")) {
+      throw new Error("Invalid external object row link.");
+    }
+    const parsed = parseExternalModelStateSnapshot({ source: null, importBatches: [], roomMappings: [], objects: [transition.expected, transition.target] }).objects;
+    const expectedRest = { ...parsed[0], circuitDeviceRowId: null };
+    const targetRest = { ...parsed[1], circuitDeviceRowId: null };
+    if (canonicalJson(expectedRest) !== canonicalJson(targetRest) || expectedRowId === targetRowId) {
+      throw new Error("External object transition may only change the row link.");
+    }
+  }
+}
+
+function canonicalJson(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (isPlainObject(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+  return JSON.stringify(value) ?? "null";
 }
 
 function assertNonEmptyString(value: unknown, field: string) {

src/domain/models/circuit-group-subtree-project-command.model.ts

@@ -3,6 +3,7 @@ import {
   type CircuitGroupSubtreeSnapshot,
 } from "./circuit-group-subtree-snapshot.model.js";
 import type { SerializedProjectCommand } from "./project-command.model.js";
+import { assertExternalObjectLinkTransitions, type ExternalObjectLinkSnapshotTransition } from "./circuit-device-row-structure-project-command.model.js";
 
 export const circuitGroupDeleteSubtreeCommandType =
   "circuit-group.delete-subtree" as const;
@@ -12,6 +13,7 @@ export const circuitGroupSubtreeCommandSchemaVersion = 1 as const;
 
 interface Payload {
   snapshot: CircuitGroupSubtreeSnapshot;
+  externalObjects?: ExternalObjectLinkSnapshotTransition[];
 }
 
 export interface CircuitGroupDeleteSubtreeProjectCommand
@@ -31,24 +33,26 @@ export type CircuitGroupSubtreeProjectCommand =
   | CircuitGroupRestoreSubtreeProjectCommand;
 
 export function createCircuitGroupDeleteSubtreeProjectCommand(
-  snapshot: CircuitGroupSubtreeSnapshot
+  snapshot: CircuitGroupSubtreeSnapshot,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitGroupDeleteSubtreeProjectCommand {
   const command: CircuitGroupDeleteSubtreeProjectCommand = {
     schemaVersion: circuitGroupSubtreeCommandSchemaVersion,
     type: circuitGroupDeleteSubtreeCommandType,
-    payload: { snapshot },
+    payload: { snapshot, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitGroupDeleteSubtreeProjectCommand(command);
   return command;
 }
 
 export function createCircuitGroupRestoreSubtreeProjectCommand(
-  snapshot: CircuitGroupSubtreeSnapshot
+  snapshot: CircuitGroupSubtreeSnapshot,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitGroupRestoreSubtreeProjectCommand {
   const command: CircuitGroupRestoreSubtreeProjectCommand = {
     schemaVersion: circuitGroupSubtreeCommandSchemaVersion,
     type: circuitGroupRestoreSubtreeCommandType,
-    payload: { snapshot },
+    payload: { snapshot, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitGroupRestoreSubtreeProjectCommand(command);
   return command;
@@ -76,11 +80,12 @@ function assertCommand(
     command.schemaVersion !== circuitGroupSubtreeCommandSchemaVersion ||
     command.type !== type ||
     !isPlainObject(command.payload) ||
-    Object.keys(command.payload).length !== 1
+    Object.keys(command.payload).some((key) => key !== "snapshot" && key !== "externalObjects")
   ) {
     throw new Error("Unsupported circuit-group subtree command.");
   }
   assertCircuitGroupSubtreeSnapshot(command.payload.snapshot);
+  assertExternalObjectLinkTransitions(command.payload.externalObjects);
 }
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {

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

@@ -3,6 +3,8 @@ import {
   circuitDeviceRowInsertCommandType,
   circuitDeviceRowStructureCommandSchemaVersion,
   type CircuitDeviceRowSnapshot,
+  type ExternalObjectLinkSnapshotTransition,
+  assertExternalObjectLinkTransitions,
 } from "./circuit-device-row-structure-project-command.model.js";
 import type { SerializedProjectCommand } from "./project-command.model.js";
 import {
@@ -37,11 +39,13 @@ export interface CircuitSnapshot {
 
 export interface CircuitInsertCommandPayload {
   circuit: CircuitSnapshot;
+  externalObjects?: ExternalObjectLinkSnapshotTransition[];
 }
 
 export interface CircuitDeleteCommandPayload {
   circuitId: string;
   expectedCircuitListId: string;
+  externalObjects?: ExternalObjectLinkSnapshotTransition[];
 }
 
 export interface CircuitInsertProjectCommand
@@ -61,12 +65,13 @@ export type CircuitStructureProjectCommand =
   | CircuitDeleteProjectCommand;
 
 export function createCircuitInsertProjectCommand(
-  circuit: CircuitSnapshot
+  circuit: CircuitSnapshot,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitInsertProjectCommand {
   const command: CircuitInsertProjectCommand = {
     schemaVersion: circuitStructureCommandSchemaVersion,
     type: circuitInsertCommandType,
-    payload: { circuit },
+    payload: { circuit, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitInsertProjectCommand(command);
   return command;
@@ -74,12 +79,13 @@ export function createCircuitInsertProjectCommand(
 
 export function createCircuitDeleteProjectCommand(
   circuitId: string,
-  expectedCircuitListId: string
+  expectedCircuitListId: string,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitDeleteProjectCommand {
   const command: CircuitDeleteProjectCommand = {
     schemaVersion: circuitStructureCommandSchemaVersion,
     type: circuitDeleteCommandType,
-    payload: { circuitId, expectedCircuitListId },
+    payload: { circuitId, expectedCircuitListId, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitDeleteProjectCommand(command);
   return command;
@@ -168,6 +174,7 @@ export function assertCircuitInsertProjectCommand(
     }
     rowIds.add(row.id);
   }
+  assertExternalObjectLinkTransitions(command.payload.externalObjects);
 }
 
 export function assertCircuitDeleteProjectCommand(
@@ -187,6 +194,7 @@ export function assertCircuitDeleteProjectCommand(
     command.payload.expectedCircuitListId,
     "expectedCircuitListId"
   );
+  assertExternalObjectLinkTransitions(command.payload.externalObjects);
 }
 
 function assertNonEmptyString(value: unknown, field: string) {

src/domain/models/circuit-tree.model.ts

@@ -20,6 +20,7 @@ export interface CircuitTreeDeviceRow {
   remark?: string;
   overriddenFields?: string;
   rowTotalPower: number;
+  externalObjectCount?: number;
 }
 
 export interface CircuitTreeCircuit {

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

@@ -146,8 +146,8 @@ function assertOnlyAssignmentChanged(
   expected: ExternalModelObjectSnapshot,
   target: ExternalModelObjectSnapshot
 ) {
-  const expectedRest = { ...expected, circuitDeviceRowId: null };
-  const targetRest = { ...target, circuitDeviceRowId: null };
+  const expectedRest = { ...expected, circuitDeviceRowId: null, distributionBoardId: null };
+  const targetRest = { ...target, circuitDeviceRowId: null, distributionBoardId: null };
   if (canonicalJson(expectedRest) !== canonicalJson(targetRest)) {
     throw new Error("New-circuit assignment may only change the external object row link.");
   }

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

@@ -141,8 +141,8 @@ function assertOnlyAssignmentChanged(
   expected: ExternalModelObjectSnapshot,
   target: ExternalModelObjectSnapshot
 ) {
-  const expectedRest = { ...expected, circuitDeviceRowId: null };
-  const targetRest = { ...target, circuitDeviceRowId: null };
+  const expectedRest = { ...expected, circuitDeviceRowId: null, distributionBoardId: null };
+  const targetRest = { ...target, circuitDeviceRowId: null, distributionBoardId: null };
   if (canonicalJson(expectedRest) !== canonicalJson(targetRest)) {
     throw new Error("New-row assignment may only change the external object row link.");
   }

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

@@ -104,10 +104,10 @@ export function assertExternalObjectRowAssignmentProjectCommand(
     if (expected.circuitDeviceRowId === target.circuitDeviceRowId) {
       throw new Error("External object row assignment must change its row link.");
     }
-    assertOnlyFieldChanged(
+    assertOnlyFieldsChanged(
       expected as unknown as Record<string, unknown>,
       target as unknown as Record<string, unknown>,
-      "circuitDeviceRowId",
+      new Set(["circuitDeviceRowId", "distributionBoardId", "linkedProjectDeviceId", "planningValues", "overriddenFields"]),
       "external object"
     );
     if (expected.circuitDeviceRowId) affectedRowIds.add(expected.circuitDeviceRowId);
@@ -161,11 +161,22 @@ function assertOnlyFieldChanged(
   target: Record<string, unknown>,
   allowedField: string,
   label: string
+) {
+  assertOnlyFieldsChanged(expected, target, new Set([allowedField]), label);
+}
+
+function assertOnlyFieldsChanged(
+  expected: Record<string, unknown>,
+  target: Record<string, unknown>,
+  allowedFields: ReadonlySet<string>,
+  label: string
 ) {
   const expectedRest = { ...expected };
   const targetRest = { ...target };
-  delete expectedRest[allowedField];
-  delete targetRest[allowedField];
+  for (const field of allowedFields) {
+    delete expectedRest[field];
+    delete targetRest[field];
+  }
   if (canonicalJson(expectedRest) !== canonicalJson(targetRest)) {
     throw new Error(`Row assignment may only change the ${label} assignment state.`);
   }

src/external-model/application/external-xlsx-return-projection.ts

@@ -0,0 +1,135 @@
+import type { ExternalModelObjectSnapshot } from "../domain/external-model-contracts.js";
+import type { ExternalXlsxCircuitMode, ExternalXlsxReturnValues } from "../xlsx/external-xlsx-contracts.js";
+import type { CircuitGroupCategory } from "../../shared/constants/circuit-group.js";
+
+export interface ExternalReturnRowContext {
+  rowId: string;
+  displayName: string;
+  powerPerUnitKw: number;
+  cosPhi: number | null;
+  phaseType: string | null;
+  category: CircuitGroupCategory | null;
+  circuitIdentifier: string;
+  circuitVoltageV: number | null;
+  distributionBoardName: string;
+}
+
+export interface ExternalReturnProjection {
+  objectId: string;
+  worksharingId: string;
+  values: ExternalXlsxReturnValues;
+  differsFromImported: boolean;
+  warnings: string[];
+}
+
+export function getRevitBoardName(board: { name: string }) {
+  return board.name;
+}
+
+export function projectExternalXlsxReturn(input: {
+  object: ExternalModelObjectSnapshot;
+  row: ExternalReturnRowContext | null;
+  circuitMode: ExternalXlsxCircuitMode;
+  singlePhaseVoltageV: number;
+  threePhaseVoltageV: number;
+}): ExternalReturnProjection {
+  const { object, row } = input;
+  const planning = object.planningValues;
+  const warnings: string[] = [];
+  const category = row?.category ?? planning.category;
+  const phaseType = row?.phaseType ?? (category === "three_phase" ? "three_phase" : category ? "single_phase" : null);
+  const voltageV = row?.circuitVoltageV ?? defaultVoltage(category, input.singlePhaseVoltageV, input.threePhaseVoltageV);
+  const powerPerUnitW = row ? row.powerPerUnitKw * 1000 : planning.powerPerUnitW;
+  const electricalPowerW = powerPerUnitW === null
+    ? null
+    : roundNumber(planning.effectiveQuantity * powerPerUnitW, 6);
+  const cosPhi = row?.cosPhi ?? planning.cosPhi;
+  const currentA = calculateCurrent({ electricalPowerW, voltageV, cosPhi, phaseType });
+  if (electricalPowerW === null) warnings.push("Elektrische Leistung ist nicht berechenbar.");
+  if (voltageV === null) warnings.push("Spannung ist nicht bestimmbar.");
+  if (currentA === null) warnings.push("Stromstärke ist nicht berechenbar.");
+
+  const values: ExternalXlsxReturnValues = {
+    ...(input.circuitMode === "combined"
+      ? { circuitCombined: row ? `${getRevitBoardName({ name: row.distributionBoardName })}${row.circuitIdentifier}` : "" }
+      : {
+          boardName: row ? getRevitBoardName({ name: row.distributionBoardName }) : "",
+          circuitIdentifier: row?.circuitIdentifier ?? "",
+        }),
+    designation: row?.displayName ?? planning.displayName ?? "",
+    electricalPowerW,
+    voltageV,
+    currentA,
+  };
+  const source = object.acceptedSourceValues;
+  const sourceValues: ExternalXlsxReturnValues = input.circuitMode === "combined"
+    ? {
+        circuitCombined: source.circuitCombined,
+        designation: source.designation,
+        electricalPowerW: source.electricalPowerW,
+        voltageV: source.voltageV,
+        currentA: source.currentA,
+      }
+    : {
+        boardName: source.boardName,
+        circuitIdentifier: source.circuitIdentifier,
+        designation: source.designation,
+        electricalPowerW: source.electricalPowerW,
+        voltageV: source.voltageV,
+        currentA: source.currentA,
+      };
+
+  return {
+    objectId: object.id,
+    worksharingId: object.worksharingId,
+    values,
+    differsFromImported: Object.keys(values).some((key) =>
+      !sameScalar(values[key as keyof ExternalXlsxReturnValues], sourceValues[key as keyof ExternalXlsxReturnValues])
+    ),
+    warnings,
+  };
+}
+
+function defaultVoltage(category: CircuitGroupCategory | null, singlePhase: number, threePhase: number) {
+  if (category === "three_phase") return threePhase;
+  if (category === "lighting" || category === "single_phase") return singlePhase;
+  return null;
+}
+
+function calculateCurrent(input: { electricalPowerW: number | null; voltageV: number | null; cosPhi: number | null; phaseType: string | null }) {
+  if (
+    input.electricalPowerW === null ||
+    input.voltageV === null || input.voltageV <= 0 ||
+    input.cosPhi === null || input.cosPhi <= 0 ||
+    (input.phaseType !== "single_phase" && input.phaseType !== "three_phase")
+  ) return null;
+  const divisor = input.phaseType === "three_phase"
+    ? Math.sqrt(3) * input.voltageV * input.cosPhi
+    : input.voltageV * input.cosPhi;
+  return roundNumber(input.electricalPowerW / divisor, 2);
+}
+
+function sameScalar(left: string | number | boolean | null | undefined, right: string | number | boolean | null | undefined) {
+  const normalizedLeft = normalizeScalar(left);
+  const normalizedRight = normalizeScalar(right);
+  if (typeof normalizedLeft === "number" && typeof normalizedRight === "number") {
+    return Math.abs(normalizedLeft - normalizedRight) < 1e-9;
+  }
+  return normalizedLeft === normalizedRight;
+}
+
+function normalizeScalar(value: string | number | boolean | null | undefined): string | number | boolean {
+  if (value === null || value === undefined || value === "") return "";
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return "";
+    const numeric = Number(trimmed.replace(",", "."));
+    return Number.isFinite(numeric) ? numeric : trimmed;
+  }
+  return value;
+}
+
+function roundNumber(value: number, decimals: number) {
+  const factor = 10 ** decimals;
+  return Math.round((value + Number.EPSILON) * factor) / factor;
+}

src/frontend/components/circuit-tree-editor.tsx

@@ -120,6 +120,11 @@ import {
   deleteCircuitGroupCommand,
   deleteCircuitGroupSubtreeCommand,
   deleteDistributionBoardComponentCommand,
+  assignExternalProjectObjectsToRow,
+  assignExternalProjectObjectsToNewRow,
+  assignExternalProjectObjectsToNewCircuit,
+  detachExternalProjectObjectsFromRow,
+  getExternalProjectObjects,
   getCircuitTree,
   getNextCircuitIdentifier,
   getProjectHistory,
@@ -154,6 +159,7 @@ import type {
   ProjectCommandResultDto,
   ProjectDeviceDto,
   ProjectHistoryStateDto,
+  ExternalProjectObjectsDto,
 } from "../types";
 import type {
   CircuitDeviceRowSnapshot,
@@ -330,6 +336,9 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
   const [cableSizingEditorCircuit, setCableSizingEditorCircuit] =
     useState<CircuitTreeCircuitDto | null>(null);
   const [projectDevices, setProjectDevices] = useState<ProjectDeviceDto[]>([]);
+  const [externalObjects, setExternalObjects] = useState<ExternalProjectObjectsDto | null>(null);
+  const [isRevitDrawerOpen, setIsRevitDrawerOpen] = useState(false);
+  const [draggingExternalObjectIds, setDraggingExternalObjectIds] = useState<string[]>([]);
   const [isProjectDeviceDrawerOpen, setIsProjectDeviceDrawerOpen] =
     useState(false);
   const [projectDeviceSearch, setProjectDeviceSearch] = useState("");
@@ -381,6 +390,26 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     () => orderedColumns.filter((column) => visibleColumnKeys.includes(column.key)),
     [orderedColumns, visibleColumnKeys]
   );
+  const externalObjectGroups = useMemo(() => {
+    if (!data || !externalObjects) return [];
+    const groups = new Map<string, typeof externalObjects.objects>();
+    for (const object of externalObjects.objects) {
+      if (object.presenceStatus !== "present" || object.circuitDeviceRowId !== null || object.distributionBoardId !== data.distributionBoardId) continue;
+      const key = JSON.stringify([
+        object.roomId, object.selectionMarker, object.deviceTypeId,
+        object.planningValues.category, object.linkedProjectDeviceId,
+        object.planningValues,
+      ]);
+      const entries = groups.get(key) ?? [];
+      entries.push(object);
+      groups.set(key, entries);
+    }
+    return [...groups.values()].map((objects) => ({
+      key: objects.map((object) => object.id).sort().join("|"),
+      objects,
+      quantity: objects.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0),
+    }));
+  }, [data, externalObjects]);
 
   async function loadTree(options?: { showLoading?: boolean }) {
     const showLoading = options?.showLoading ?? false;
@@ -389,13 +418,17 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     }
     setError(null);
     try {
-      const { tree, history } = await loadCircuitEditorSnapshot(
-        () => getCircuitTree(projectId, circuitListId),
-        () => getProjectHistory(projectId)
-      );
+      const [{ tree, history }, external] = await Promise.all([
+        loadCircuitEditorSnapshot(
+          () => getCircuitTree(projectId, circuitListId),
+          () => getProjectHistory(projectId)
+        ),
+        getExternalProjectObjects(projectId),
+      ]);
       projectRevisionRef.current = history.currentRevision;
       setHistoryState(history);
       setData(tree);
+      setExternalObjects(external);
     } catch (err) {
       setError(normalizeUiError(err));
     } finally {
@@ -1321,12 +1354,20 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     const summary = subtree
       ? summarizeCircuitGroupSubtree(subtree)
       : null;
+    const externalObjectCount = section.circuits.reduce(
+      (total, circuit) => total + circuit.deviceRows.reduce(
+        (rowTotal, row) => rowTotal + (row.externalObjectCount ?? 0), 0
+      ), 0
+    );
+    const externalWarning = externalObjectCount > 0
+      ? `\n\n${externalObjectCount} Revit-Objekte werden wieder unzugeordnet.`
+      : "";
     const warning = isEmpty
       ? `Leere Stromkreisgruppe „${section.displayName}“ entfernen?`
       : `Stromkreisgruppe „${section.displayName}“ vollständig entfernen?\n\n` +
         `Dabei werden ${summary!.circuitCount} Stromkreis(e), ${summary!.deviceRowCount} Gerätezeile(n) und ${summary!.protectionComponentCount} Gruppenschutzgerät(e) gelöscht.\n\n` +
         "Die Änderung kann über die projektweite Versionshistorie rückgängig gemacht werden.";
-    if (!confirm(warning)) {
+    if (!confirm(warning + externalWarning)) {
       return;
     }
     await runCommand({
@@ -2878,11 +2919,15 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       setError("Die Gerätezeile ist ungültig.");
       return;
     }
+    const externalWarning = (rowSnapshot.externalObjectCount ?? 0) > 0
+      ? `\n\n${rowSnapshot.externalObjectCount} Revit-Objekte werden wieder unzugeordnet.`
+      : "";
     if (sourceCircuit.deviceRows.length === 1) {
       const keepAsReserve = confirm(
         `„${rowSnapshot.displayName}“ ist das letzte Gerät in ${sourceCircuit.equipmentIdentifier}.\n\n` +
           "OK: Gerät löschen und den leeren Stromkreis als Reserve behalten.\n" +
-          "Abbrechen: anschließend entscheiden, ob stattdessen der gesamte Stromkreis gelöscht werden soll."
+          "Abbrechen: anschließend entscheiden, ob stattdessen der gesamte Stromkreis gelöscht werden soll." +
+          externalWarning
       );
       if (!keepAsReserve) {
         const deleteCircuit = confirm(
@@ -2894,7 +2939,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
         }
         return;
       }
-    } else if (!confirm(`Gerätezeile „${rowSnapshot.displayName}“ löschen?`)) {
+    } else if (!confirm(`Gerätezeile „${rowSnapshot.displayName}“ löschen?${externalWarning}`)) {
       return;
     }
     await runCommand({
@@ -2917,11 +2962,18 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       setError("Der Stromkreis ist ungültig.");
       return;
     }
+    const externalObjectCount = circuit.deviceRows.reduce(
+      (total, row) => total + (row.externalObjectCount ?? 0), 0
+    );
+    const externalWarning = externalObjectCount > 0
+      ? `\n\n${externalObjectCount} Revit-Objekte werden wieder unzugeordnet.`
+      : "";
     if (
       askForConfirmation &&
       !confirm(
         `Stromkreis ${circuit.equipmentIdentifier} und ${circuit.deviceRows.length} zugeordnete Gerätezeile(n) löschen?\n\n` +
-          "Bestehende Betriebsmittelkennzeichen werden nicht neu nummeriert."
+          "Bestehende Betriebsmittelkennzeichen werden nicht neu nummeriert." +
+          externalWarning
       )
     ) {
       return;
@@ -2958,6 +3010,56 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     await handleDeleteCircuit(intent.circuitId);
   }
 
+  async function handleAssignExternalObjects(rowId: string, objectIds: string[]) {
+    if (!confirm(`${objectIds.length} Revit-Objekt(e) dieser Gerätezeile zuordnen?\n\nAbweichende Planungswerte werden ausdrücklich zugunsten der Gerätezeile bestätigt.`)) return;
+    await runCommand({
+      label: "Revit-Objekte zuordnen",
+      redo: async () => {
+        const result = await assignExternalProjectObjectsToRow(
+          projectId,
+          getExpectedProjectRevision(),
+          objectIds,
+          rowId,
+          objectIds
+        );
+        applyProjectCommandResult(result);
+        setDraggingExternalObjectIds([]);
+        return null;
+      },
+    });
+  }
+
+  async function handleAssignExternalObjectsToNewRow(circuitId: string, objectIds: string[]) {
+    if (!confirm(`${objectIds.length} Revit-Objekt(e) als neue Gerätezeile anlegen?`)) return;
+    await runCommand({ label: "Revit-Objekte als Gerätezeile zuordnen", redo: async () => {
+      const result = await assignExternalProjectObjectsToNewRow(projectId, getExpectedProjectRevision(), objectIds, circuitId);
+      applyProjectCommandResult(result); setDraggingExternalObjectIds([]); return null;
+    }});
+  }
+
+  async function handleAssignExternalObjectsToNewCircuit(sectionId: string, objectIds: string[]) {
+    if (!confirm(`${objectIds.length} Revit-Objekt(e) als neuen Stromkreis anlegen?`)) return;
+    await runCommand({ label: "Revit-Objekte als Stromkreis zuordnen", redo: async () => {
+      const result = await assignExternalProjectObjectsToNewCircuit(projectId, getExpectedProjectRevision(), objectIds, sectionId);
+      applyProjectCommandResult(result); setDraggingExternalObjectIds([]); return null;
+    }});
+  }
+
+  async function handleDetachExternalObjects(rowId: string) {
+    const objectIds = externalObjects?.objects
+      .filter((object) => object.circuitDeviceRowId === rowId)
+      .map((object) => object.id) ?? [];
+    if (objectIds.length === 0 || !confirm(`${objectIds.length} Revit-Objekt(e) lösen?\n\nDie aktuellen Werte der Gerätezeile werden als Planungswerte und Overrides übernommen.`)) return;
+    await runCommand({
+      label: "Revit-Objekte lösen",
+      redo: async () => {
+        const result = await detachExternalProjectObjectsFromRow(projectId, getExpectedProjectRevision(), objectIds);
+        applyProjectCommandResult(result);
+        return null;
+      },
+    });
+  }
+
   // Explicit renumber action through project history. Sorting and device rows
   // remain unchanged; the server handles collision-safe identifier swaps.
   async function handleRenumberSection(sectionId: string) {
@@ -3381,6 +3483,15 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
           }
           showLabel
         />
+        <IconButton
+          ariaControls="revit-object-drawer"
+          ariaExpanded={isRevitDrawerOpen}
+          className="project-device-drawer-toggle"
+          icon={isRevitDrawerOpen ? PanelRightClose : PanelRightOpen}
+          label={isRevitDrawerOpen ? "Revit-Objekte schließen" : `Revit-Objekte öffnen (${externalObjectGroups.reduce((sum, group) => sum + group.objects.length, 0)})`}
+          onClick={() => setIsRevitDrawerOpen((current) => !current)}
+          showLabel
+        />
         <IconButton
           ariaControls="project-device-drawer"
           ariaExpanded={isProjectDeviceDrawerOpen}
@@ -3419,6 +3530,62 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       ) : null}
       {isSaving ? <div className="notice info">Wird gespeichert …</div> : null}
       <div className="tree-editor-layout">
+        {isRevitDrawerOpen ? (
+          <aside className="project-device-sidebar project-device-drawer" id="revit-object-drawer">
+            <div className="project-device-drawer-header">
+              <div>
+                <h3>Revit-Objekte</h3>
+                <span>{externalObjectGroups.reduce((sum, group) => sum + group.objects.length, 0)} unzugeordnet</span>
+              </div>
+              <button type="button" onClick={() => setIsRevitDrawerOpen(false)}>Schließen</button>
+            </div>
+            <div className="project-device-list">
+              {externalObjectGroups.map((group) => {
+                const first = group.objects[0]!;
+                return (
+                  <details
+                    key={group.key}
+                    className={`project-device-item ${draggingExternalObjectIds[0] === first.id ? "dragging" : ""}`}
+                  >
+                    <summary
+                      draggable
+                      onDragStart={(event) => {
+                        const ids = group.objects.map((object) => object.id);
+                        setDraggingExternalObjectIds(ids);
+                        event.dataTransfer.effectAllowed = "move";
+                        event.dataTransfer.setData("application/x-revit-object-ids", JSON.stringify(ids));
+                      }}
+                      onDragEnd={() => setDraggingExternalObjectIds([])}
+                    >
+                      <strong>{first.planningValues.displayName || first.selectionMarker || first.familyAndType}</strong>
+                      <span>{first.sourceRoomNumber} {first.sourceRoomName}</span>
+                      <span>{group.objects.length} Objekt(e), Menge {formatValue(group.quantity, "quantity")}</span>
+                      <span>{first.familyAndType}</span>
+                    </summary>
+                    {group.objects.map((object) => (
+                      <button
+                        key={object.id}
+                        type="button"
+                        draggable
+                        className="btn btn-sm btn-outline-secondary mt-2 w-100 text-start"
+                        onDragStart={(event) => {
+                          setDraggingExternalObjectIds([object.id]);
+                          event.dataTransfer.effectAllowed = "move";
+                          event.dataTransfer.setData("application/x-revit-object-ids", JSON.stringify([object.id]));
+                          event.stopPropagation();
+                        }}
+                        onDragEnd={() => setDraggingExternalObjectIds([])}
+                      >
+                        {object.worksharingId}
+                      </button>
+                    ))}
+                  </details>
+                );
+              })}
+              {externalObjectGroups.length === 0 ? <p className="notice muted">Keine unzugeordneten Revit-Objekte für diesen Verteiler.</p> : null}
+            </div>
+          </aside>
+        ) : null}
         {isProjectDeviceDrawerOpen ? (
         <aside
           className="project-device-sidebar project-device-drawer"
@@ -4202,6 +4369,11 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                   }`}
                   onClick={() => setActiveSectionId(row.sectionId)}
                   onDragOver={(event) => {
+                    if (draggingExternalObjectIds.length > 0 && (row.device || row.circuit || row.rowType === "placeholder")) {
+                      event.preventDefault();
+                      event.dataTransfer.dropEffect = "move";
+                      return;
+                    }
                     if (draggingCircuitCount > 0) {
                       const valid = isCircuitDropTargetValid(
                         row.sectionId
@@ -4342,6 +4514,21 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                     });
                   }}
                   onDrop={(event) => {
+                    if (draggingExternalObjectIds.length > 0 && row.device) {
+                      event.preventDefault();
+                      void handleAssignExternalObjects(row.device.id, draggingExternalObjectIds);
+                      return;
+                    }
+                    if (draggingExternalObjectIds.length > 0 && row.rowType === "placeholder") {
+                      event.preventDefault();
+                      void handleAssignExternalObjectsToNewCircuit(row.sectionId, draggingExternalObjectIds);
+                      return;
+                    }
+                    if (draggingExternalObjectIds.length > 0 && row.circuit) {
+                      event.preventDefault();
+                      void handleAssignExternalObjectsToNewRow(row.circuit.id, draggingExternalObjectIds);
+                      return;
+                    }
                     if (draggingCircuitCount > 0) {
                       if (row.rowType === "placeholder") {
                         void handleCircuitReorderDrop(event, {
@@ -4728,14 +4915,26 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                       </>
                     ) : null}
                     {row.device ? (
-                      <IconButton
-                        disabled={isSaving}
-                        icon={ListX}
-                        label="Gerät löschen"
-                        onClick={() => void handleDeleteDevice(row.device!.id)}
-                        tabIndex={-1}
-                        variant="danger"
-                      />
+                      <>
+                        {(row.device.externalObjectCount ?? 0) > 0 ? (
+                          <button
+                            type="button"
+                            className="badge rounded-pill text-bg-info border-0"
+                            title="Verknüpfte Revit-Objekte anzeigen und lösen"
+                            onClick={() => void handleDetachExternalObjects(row.device!.id)}
+                          >
+                            Revit {row.device.externalObjectCount}
+                          </button>
+                        ) : null}
+                        <IconButton
+                          disabled={isSaving}
+                          icon={ListX}
+                          label="Gerät löschen"
+                          onClick={() => void handleDeleteDevice(row.device!.id)}
+                          tabIndex={-1}
+                          variant="danger"
+                        />
+                      </>
                     ) : null}
                     {dropIntent?.kind === "new-circuit" && row.rowType === "placeholder" && dropIntent.sectionId === row.sectionId ? (
                       <span className="drop-hint">

src/frontend/components/revit-object-table.tsx

@@ -1,8 +1,8 @@
 "use client";
 
 import { useEffect, useMemo, useState } from "react";
-import type { ExternalProjectObjectsDto } from "../types";
-import { getExternalProjectObjects, updateExternalProjectObjects } from "../utils/api";
+import type { ExternalProjectObjectsDto, ExternalReturnScopeDto } from "../types";
+import { createExternalReturnWorkbook, getExternalProjectObjects, updateExternalProjectObjects } from "../utils/api";
 
 const rowHeight = 44;
 const viewportHeight = 520;
@@ -23,6 +23,10 @@ export function RevitObjectTable({ projectId, onRevision }: { projectId: string;
   const [planningValue, setPlanningValue] = useState("");
   const [error, setError] = useState<string | null>(null);
   const [saving, setSaving] = useState(false);
+  const [returnScope, setReturnScope] = useState<ExternalReturnScopeDto>("all");
+  const [exporting, setExporting] = useState(false);
+  const [exportWarnings, setExportWarnings] = useState<string[]>([]);
+  const [exportMessage, setExportMessage] = useState<string | null>(null);
 
   async function load() { try { const loaded = await getExternalProjectObjects(projectId); setData(loaded); onRevision(loaded.currentRevision); } catch (value) { setError(value instanceof Error ? value.message : "Revit-Objekte konnten nicht geladen werden."); } }
   useEffect(() => { void load(); }, [projectId]); // eslint-disable-line react-hooks/exhaustive-deps
@@ -44,6 +48,7 @@ export function RevitObjectTable({ projectId, onRevision }: { projectId: string;
   const first = Math.max(0, Math.floor(scrollTop / rowHeight) - 5);
   const visible = rows.slice(first, first + Math.ceil(viewportHeight / rowHeight) + 10);
   const selectable = rows.filter((object) => object.circuitDeviceRowId === null);
+  const selectedHasLinkedObject = data?.objects.some((object) => selected.has(object.id) && object.circuitDeviceRowId !== null) ?? false;
 
   async function applyBulk() {
     if (!data || selected.size === 0) return;
@@ -64,10 +69,38 @@ export function RevitObjectTable({ projectId, onRevision }: { projectId: string;
     finally { setSaving(false); }
   }
 
+  async function exportReturnWorkbook() {
+    if (!data || (returnScope === "selected" && selected.size === 0)) return;
+    setExporting(true); setError(null); setExportWarnings([]); setExportMessage(null);
+    try {
+      const result = await createExternalReturnWorkbook(projectId, data.currentRevision, returnScope, [...selected]);
+      downloadBase64(result.contentBase64, result.fileName);
+      setExportWarnings(result.warnings);
+      setExportMessage(`${result.objectCount} Revit-Objekte wurden in ${result.fileName} geschrieben.`);
+    } catch (value) {
+      setError(value instanceof Error ? value.message : "Rückgabe-Excel konnte nicht erstellt werden.");
+    } finally {
+      setExporting(false);
+    }
+  }
+
   if (!data) return <section className="card mt-3"><div className="card-body">Revit-Objekte werden geladen …</div></section>;
   return <section className="card mt-3"><div className="card-body"><div className="d-flex justify-content-between align-items-start gap-3 flex-wrap mb-3"><div><h2 className="h5 mb-1">Revit-Objekte</h2><div className="text-secondary small">{rows.length} von {data.objects.length} · {selected.size} ausgewählt</div></div><div className="d-flex gap-2 flex-wrap"><input aria-label="Revit-Objekte suchen" className="form-control" placeholder="Suchen …" value={search} onChange={(event) => setSearch(event.target.value)} /><select aria-label="Verteiler filtern" className="form-select" value={boardFilter} onChange={(event) => setBoardFilter(event.target.value)}><option value="all">Alle Verteiler</option><option value="none">Ohne Verteiler</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select><select aria-label="Zuordnung filtern" className="form-select" value={assignmentFilter} onChange={(event) => setAssignmentFilter(event.target.value)}><option value="all">Alle Zuordnungen</option><option value="unassigned">Unzugeordnet</option><option value="linked">Mit Gerätezeile</option></select><select aria-label="Sortierung" className="form-select" value={sort} onChange={(event) => setSort(event.target.value as typeof sort)}><option value="family">Familie</option><option value="room">Raum</option><option value="worksharing">Worksharing-ID</option></select></div></div>
     {error ? <div className="alert alert-danger">{error}</div> : null}
-    <div className="border rounded mb-3" style={{ height: viewportHeight, overflowY: "auto" }} onScroll={(event) => setScrollTop(event.currentTarget.scrollTop)}><div style={{ height: rows.length * rowHeight, position: "relative" }}>{visible.map((object, index) => { const top = (first + index) * rowHeight; const linked = object.circuitDeviceRowId !== null; return <div className="d-grid align-items-center border-bottom px-2" key={object.id} style={{ gridTemplateColumns: "32px minmax(180px,2fr) minmax(120px,1fr) minmax(120px,1fr) minmax(130px,1fr) 100px", height: rowHeight, left: 0, position: "absolute", right: 0, top }}><input aria-label={`${object.familyAndType} auswählen`} checked={selected.has(object.id)} disabled={linked} type="checkbox" onChange={() => setSelected((current) => { const next = new Set(current); if (next.has(object.id)) next.delete(object.id); else next.add(object.id); return next; })} /><div className="text-truncate"><strong>{object.planningValues.displayName ?? object.familyAndType}</strong><div className="small text-secondary text-truncate">{object.familyAndType}</div></div><div className="text-truncate">{object.sourceRoomNumber} {object.sourceRoomName}</div><div className="text-truncate">{data.distributionBoards.find((board) => board.id === object.distributionBoardId)?.name ?? "Ohne Verteiler"}</div><div className="text-truncate">{object.selectionMarker || object.worksharingId}</div><span className={`badge ${linked ? "text-bg-success" : "text-bg-secondary"}`}>{linked ? "verknüpft" : "frei"}</span></div>; })}</div></div>
-    <div className="d-flex gap-2 flex-wrap align-items-end"><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(selectable.map((object) => object.id)))}>Sichtbare freie auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set())}>Auswahl leeren</button><label className="small">Verteiler<select className="form-select form-select-sm" value={bulkBoard} onChange={(event) => setBulkBoard(event.target.value)}><option value="">Unverändert</option><option value="none">Zuordnung lösen</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></label><label className="small">Projektgerät<select className="form-select form-select-sm" value={bulkDevice} onChange={(event) => setBulkDevice(event.target.value)}><option value="">Unverändert</option><option value="none">Verknüpfung lösen</option>{data.projectDevices.map((device) => <option value={device.id} key={device.id}>{device.name}</option>)}</select></label><label className="small">Leistung [W]<input className="form-control form-control-sm" inputMode="decimal" value={power} onChange={(event) => setPower(event.target.value)} /></label><label className="small">GZF<input className="form-control form-control-sm" inputMode="decimal" value={gzf} onChange={(event) => setGzf(event.target.value)} /></label><label className="small">Weiterer Planungswert<select className="form-select form-select-sm" value={planningField} onChange={(event) => setPlanningField(event.target.value)}><option value="">Unverändert</option><option value="displayName">Anzeigename</option><option value="category">Kategorie (lighting/single_phase/three_phase)</option><option value="connectionKind">Anschlussart</option><option value="effectiveQuantity">Wirksame Menge</option><option value="cosPhi">cosPhi</option><option value="costGroup">Kostengruppe</option><option value="remark">Bemerkung</option></select></label>{planningField ? <label className="small">Neuer Wert<input className="form-control form-control-sm" value={planningValue} onChange={(event) => setPlanningValue(event.target.value)} /></label> : null}<button className="btn btn-sm btn-primary" disabled={saving || selected.size === 0} type="button" onClick={() => void applyBulk()}>{saving ? "Wird gespeichert …" : "Sammeländerung anwenden"}</button></div>
+    <div className="border rounded p-3 mb-3"><div className="d-flex gap-2 align-items-end flex-wrap"><label className="small">Rückgabeumfang<select aria-label="Rückgabeumfang" className="form-select form-select-sm" value={returnScope} onChange={(event) => setReturnScope(event.target.value as ExternalReturnScopeDto)}><option value="all">Alle Objekte des letzten Imports</option><option value="deviating">Nur geänderte Objekte</option><option value="selected">Nur ausgewählte Objekte</option></select></label><button className="btn btn-sm btn-primary" disabled={exporting || (returnScope === "selected" && selected.size === 0)} type="button" onClick={() => void exportReturnWorkbook()}>{exporting ? "Rückgabe wird erstellt …" : "Rückgabe-Excel herunterladen"}</button></div>{exportMessage ? <div className="alert alert-success mt-3 mb-0">{exportMessage}</div> : null}{exportWarnings.length ? <div className="alert alert-warning mt-3 mb-0"><strong>Hinweise zur Rückgabe:</strong><ul className="mb-0">{exportWarnings.map((warning) => <li key={warning}>{warning}</li>)}</ul></div> : null}</div>
+    <div className="border rounded mb-3" style={{ height: viewportHeight, overflowY: "auto" }} onScroll={(event) => setScrollTop(event.currentTarget.scrollTop)}><div style={{ height: rows.length * rowHeight, position: "relative" }}>{visible.map((object, index) => { const top = (first + index) * rowHeight; const linked = object.circuitDeviceRowId !== null; return <div className="d-grid align-items-center border-bottom px-2" key={object.id} style={{ gridTemplateColumns: "32px minmax(180px,2fr) minmax(120px,1fr) minmax(120px,1fr) minmax(130px,1fr) 100px", height: rowHeight, left: 0, position: "absolute", right: 0, top }}><input aria-label={`${object.familyAndType} auswählen`} checked={selected.has(object.id)} type="checkbox" onChange={() => setSelected((current) => { const next = new Set(current); if (next.has(object.id)) next.delete(object.id); else next.add(object.id); return next; })} /><div className="text-truncate"><strong>{object.planningValues.displayName ?? object.familyAndType}</strong><div className="small text-secondary text-truncate">{object.familyAndType}</div></div><div className="text-truncate">{object.sourceRoomNumber} {object.sourceRoomName}</div><div className="text-truncate">{data.distributionBoards.find((board) => board.id === object.distributionBoardId)?.name ?? "Ohne Verteiler"}</div><div className="text-truncate">{object.selectionMarker || object.worksharingId}</div><span className={`badge ${linked ? "text-bg-success" : "text-bg-secondary"}`}>{linked ? "verknüpft" : "frei"}</span></div>; })}</div></div>
+    <div className="d-flex gap-2 flex-wrap align-items-end"><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(rows.map((object) => object.id)))}>Sichtbare für Rückgabe auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(selectable.map((object) => object.id)))}>Sichtbare freie auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set())}>Auswahl leeren</button><label className="small">Verteiler<select className="form-select form-select-sm" value={bulkBoard} onChange={(event) => setBulkBoard(event.target.value)}><option value="">Unverändert</option><option value="none">Zuordnung lösen</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></label><label className="small">Projektgerät<select className="form-select form-select-sm" value={bulkDevice} onChange={(event) => setBulkDevice(event.target.value)}><option value="">Unverändert</option><option value="none">Verknüpfung lösen</option>{data.projectDevices.map((device) => <option value={device.id} key={device.id}>{device.name}</option>)}</select></label><label className="small">Leistung [W]<input className="form-control form-control-sm" inputMode="decimal" value={power} onChange={(event) => setPower(event.target.value)} /></label><label className="small">GZF<input className="form-control form-control-sm" inputMode="decimal" value={gzf} onChange={(event) => setGzf(event.target.value)} /></label><label className="small">Weiterer Planungswert<select className="form-select form-select-sm" value={planningField} onChange={(event) => setPlanningField(event.target.value)}><option value="">Unverändert</option><option value="displayName">Anzeigename</option><option value="category">Kategorie (lighting/single_phase/three_phase)</option><option value="connectionKind">Anschlussart</option><option value="effectiveQuantity">Wirksame Menge</option><option value="cosPhi">cosPhi</option><option value="costGroup">Kostengruppe</option><option value="remark">Bemerkung</option></select></label>{planningField ? <label className="small">Neuer Wert<input className="form-control form-control-sm" value={planningValue} onChange={(event) => setPlanningValue(event.target.value)} /></label> : null}<button className="btn btn-sm btn-primary" disabled={saving || selected.size === 0 || selectedHasLinkedObject} title={selectedHasLinkedObject ? "Sammeländerungen sind nur für freie Revit-Objekte möglich." : undefined} type="button" onClick={() => void applyBulk()}>{saving ? "Wird gespeichert …" : "Sammeländerung anwenden"}</button></div>
   </div></section>;
 }
+
+function downloadBase64(contentBase64: string, fileName: string) {
+  const binary = atob(contentBase64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  const url = URL.createObjectURL(new Blob([bytes], { type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" }));
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = fileName;
+  anchor.click();
+  URL.revokeObjectURL(url);
+}

src/frontend/components/revit-xlsx-settings-modal.tsx

@@ -13,8 +13,9 @@ const labels: Record<ExternalXlsxColumnKey, string> = {
   electricalPowerW: "Elektrische Leistung", voltageV: "Spannung", currentA: "Stromstärke",
 };
 
-export function RevitXlsxSettingsModal({ configuration, isSaving, onClose, onInspectSample, onSave }: {
+export function RevitXlsxSettingsModal({ configuration, isNewConfiguration = false, isSaving, onClose, onInspectSample, onSave }: {
   configuration: ExternalModelConfiguration;
+  isNewConfiguration?: boolean;
   isSaving: boolean;
   onClose: () => void;
   onInspectSample: (file: File, configuration: ExternalModelConfiguration) => Promise<string>;
@@ -33,7 +34,7 @@ export function RevitXlsxSettingsModal({ configuration, isSaving, onClose, onIns
     }
   }
 
-  return <FormModal title="Revit-XLSX-Einstellungen" description="Layout und Spalten der Linear-Bauteilliste" isSaving={isSaving} onClose={onClose} submitDisabled={JSON.stringify(draft) === JSON.stringify(configuration)} submitLabel="Einstellungen speichern" onSubmit={(event: FormEvent) => { event.preventDefault(); void onSave(draft); }}>
+  return <FormModal title="Revit-XLSX-Einstellungen" description="Layout und Spalten der Linear-Bauteilliste" isSaving={isSaving} onClose={onClose} submitDisabled={!isNewConfiguration && JSON.stringify(draft) === JSON.stringify(configuration)} submitLabel="Einstellungen speichern" onSubmit={(event: FormEvent) => { event.preventDefault(); void onSave(draft); }}>
     <div className="row g-3">
       <div className="col-12"><label className="form-label" htmlFor="revit-sample">Musterdatei prüfen</label><input id="revit-sample" className="form-control" type="file" accept=".xlsx" onChange={(event) => void inspectSample(event.target.files?.[0])} />{sampleStatus ? <div className="form-text">{sampleStatus}</div> : null}</div>
       {(["headerRow", "firstDataRow", "firstDataColumn"] as const).map((key) => <div className="col-md-4" key={key}><label className="form-label" htmlFor={`layout-${key}`}>{key === "headerRow" ? "Kopfzeile" : key === "firstDataRow" ? "Erste Datenzeile" : "Erste Datenspalte"}</label><input id={`layout-${key}`} className="form-control" min={1} type="number" value={draft.layout[key]} onChange={(event) => setDraft({ ...draft, layout: { ...draft.layout, [key]: Number(event.target.value) } })} /></div>)}

src/frontend/types.ts

@@ -126,6 +126,29 @@ export interface ExternalProjectObjectsDto {
   objects: ExternalProjectObjectDto[];
 }
 
+export type ExternalReturnScopeDto = "all" | "deviating" | "selected";
+
+export interface ExternalReturnWorkbookDto {
+  fileName: string;
+  contentBase64: string;
+  sha256: string;
+  objectCount: number;
+  warnings: string[];
+}
+
+export interface ExternalExportBatchDto {
+  id: string;
+  projectId: string;
+  projectRevision: number;
+  importBatchId: string;
+  exportedAtIso: string;
+  fileName: string;
+  sha256: string;
+  configurationSha256: string;
+  scope: ExternalReturnScopeDto;
+  objectCount: number;
+}
+
 export interface ProjectDto {
   id: string;
   name: string;
@@ -447,6 +470,7 @@ export interface CircuitTreeDeviceRowDto {
   remark?: string;
   overriddenFields?: string;
   rowTotalPower: number;
+  externalObjectCount?: number;
 }
 
 export interface CircuitTreeProtectionDeviceDto {

src/frontend/utils/api.ts

@@ -44,6 +44,8 @@ import type {
   ExternalInitialImportStatusDto,
   ApplyExternalInitialImportInput,
   ExternalProjectObjectsDto,
+  ExternalReturnScopeDto,
+  ExternalReturnWorkbookDto,
   CreateEstimateBalanceInput,
   EstimateBalanceCommandResultDto,
   EstimateBalanceDto,
@@ -245,6 +247,44 @@ export function updateExternalProjectObjects(projectId: string, expectedRevision
   return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects`, { method: "PUT", body: JSON.stringify({ expectedRevision, objectIds, patch }) });
 }
 
+export function createExternalReturnWorkbook(
+  projectId: string,
+  expectedRevision: number,
+  scope: ExternalReturnScopeDto,
+  selectedObjectIds: string[]
+) {
+  return request<ExternalReturnWorkbookDto>(`/api/projects/${projectId}/external-model/return-workbook`, {
+    method: "POST",
+    body: JSON.stringify({ expectedRevision, scope, selectedObjectIds }),
+  });
+}
+
+export function assignExternalProjectObjectsToRow(projectId: string, expectedRevision: number, objectIds: string[], rowId: string, confirmedConflictObjectIds: string[] = []) {
+  return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects/assign-row`, {
+    method: "POST",
+    body: JSON.stringify({ expectedRevision, objectIds, rowId, confirmedConflictObjectIds }),
+  });
+}
+
+export function detachExternalProjectObjectsFromRow(projectId: string, expectedRevision: number, objectIds: string[]) {
+  return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects/detach-row`, {
+    method: "POST",
+    body: JSON.stringify({ expectedRevision, objectIds }),
+  });
+}
+
+export function assignExternalProjectObjectsToNewRow(projectId: string, expectedRevision: number, objectIds: string[], circuitId: string) {
+  return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects/assign-new-row`, {
+    method: "POST", body: JSON.stringify({ expectedRevision, objectIds, circuitId }),
+  });
+}
+
+export function assignExternalProjectObjectsToNewCircuit(projectId: string, expectedRevision: number, objectIds: string[], sectionId: string) {
+  return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects/assign-new-circuit`, {
+    method: "POST", body: JSON.stringify({ expectedRevision, objectIds, sectionId }),
+  });
+}
+
 export function getProjectHistory(projectId: string) {
   return request<ProjectHistoryStateDto>(
     `/api/projects/${projectId}/history`

src/server/composition/application-repositories.ts

@@ -15,6 +15,7 @@ import { ProjectRepository } from "../../db/repositories/project.repository.js";
 import { RoomRepository } from "../../db/repositories/room.repository.js";
 import { ExternalModelConfigurationRepository } from "../../db/repositories/external-model-configuration.repository.js";
 import { ExternalModelStateRepository } from "../../db/repositories/external-model-state.repository.js";
+import { ExternalExportBatchRepository } from "../../db/repositories/external-export-batch.repository.js";
 import { DocumentBrandingRepository } from "../../db/repositories/document-branding.repository.js";
 import { UserRepository } from "../../db/repositories/user.repository.js";
 
@@ -39,5 +40,6 @@ export const roomRepository = new RoomRepository(db);
 export const externalModelConfigurationRepository =
   new ExternalModelConfigurationRepository(db);
 export const externalModelStateRepository = new ExternalModelStateRepository(db);
+export const externalExportBatchRepository = new ExternalExportBatchRepository(db);
 export const documentBrandingRepository = new DocumentBrandingRepository(db);
 export const userRepository = new UserRepository(db);

src/server/controllers/circuit-tree.controller.ts

@@ -14,6 +14,7 @@ import {
   circuitSectionRepository,
   distributionBoardComponentRepository,
   distributionBoardRepository,
+  externalModelStateRepository,
   projectRepository,
 } from "../composition/application-repositories.js";
 
@@ -88,6 +89,13 @@ export async function buildProjectCircuitTrees(
     circuitListRepository.listByProject(projectId),
     distributionBoardRepository.listByProject(projectId),
   ]);
+  const externalState = externalModelStateRepository.getByProject(projectId).state;
+  const externalCountByRowId = new Map<string, number>();
+  for (const object of externalState.objects) {
+    if (object.circuitDeviceRowId) {
+      externalCountByRowId.set(object.circuitDeviceRowId, (externalCountByRowId.get(object.circuitDeviceRowId) ?? 0) + 1);
+    }
+  }
   const listIds = lists.map((entry) => entry.id);
   const [sections, circuits, components] = await Promise.all([
     circuitSectionRepository.listByCircuitLists(listIds),
@@ -237,6 +245,7 @@ export async function buildProjectCircuitTrees(
           row.powerPerUnit,
           row.simultaneityFactor
         ),
+        externalObjectCount: externalCountByRowId.get(row.id) ?? 0,
       }));
       const circuitLoad = loads.circuits.get(circuit.id);
       if (!circuitLoad) throw new Error("Circuit load is missing.");

src/server/controllers/external-objects.controller.ts

@@ -1,9 +1,17 @@
 import type { Request, Response } from "express";
+import { randomUUID } from "node:crypto";
 import { createExternalObjectPlanningUpdateProjectCommand } from "../../domain/models/external-object-planning-project-command.model.js";
+import { createExternalObjectRowAssignmentProjectCommand } from "../../domain/models/external-object-row-assignment-project-command.model.js";
+import type { CircuitDeviceRowSnapshot } from "../../domain/models/circuit-device-row-structure-project-command.model.js";
 import type { ExternalModelObjectPlanningValues } from "../../external-model/domain/external-model-contracts.js";
 import { distributionBoardRepository, externalModelStateRepository, projectDeviceRepository, projectRepository } from "../composition/application-repositories.js";
 import { projectCommandService } from "../composition/project-command-stores.js";
 import { respondWithProjectCommandError } from "./project-command.controller.js";
+import { buildProjectCircuitTrees } from "./circuit-tree.controller.js";
+import { createExternalObjectNewRowProjectCommand, externalObjectAssignToNewRowCommandType } from "../../domain/models/external-object-new-row-project-command.model.js";
+import { createExternalObjectNewCircuitProjectCommand, externalObjectAssignToNewCircuitCommandType } from "../../domain/models/external-object-new-circuit-project-command.model.js";
+import { createDefaultCircuitProtection } from "../../domain/services/protection-device-defaults.js";
+import { circuitNumberingService } from "../composition/circuit-numbering-service.js";
 
 export async function listExternalObjects(req: Request, res: Response) {
   const projectId = String(req.params.projectId ?? "");
@@ -49,6 +57,221 @@ export function updateExternalObjects(req: Request, res: Response) {
   } catch (error) { return respondWithProjectCommandError(error, res); }
 }
 
+export async function assignExternalObjectsToRow(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const objectIds = parseObjectIds(req.body?.objectIds);
+    const rowId = requiredId(req.body?.rowId, "Ungültige Gerätezeile.");
+    const confirmedConflictObjectIds = Array.isArray(req.body?.confirmedConflictObjectIds)
+      ? req.body.confirmedConflictObjectIds.map((value: unknown) => requiredId(value, "Ungültige Konfliktbestätigung."))
+      : [];
+    const { state, projectExists } = externalModelStateRepository.getByProject(projectId);
+    if (!projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    const treeResult = await buildProjectCircuitTrees(projectId);
+    const location = findRow(treeResult, rowId);
+    if (!location) throw new Error("Gerätezeile wurde nicht gefunden.");
+    const byId = new Map(state.objects.map((object) => [object.id, object]));
+    const selected = objectIds.map((id) => {
+      const object = byId.get(id);
+      if (!object) throw new Error("Ein Revit-Objekt wurde nicht gefunden.");
+      if (object.circuitDeviceRowId !== null) throw new Error("Ein Revit-Objekt ist bereits einer Gerätezeile zugeordnet.");
+      return object;
+    });
+    const expectedRow = toRowSnapshot(location.row, location.circuitId);
+    const addedQuantity = selected.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0);
+    const targetRow = { ...expectedRow, quantity: expectedRow.quantity + addedQuantity };
+    const objects = selected.map((expected) => ({
+      expected,
+      target: { ...expected, distributionBoardId: location.distributionBoardId, circuitDeviceRowId: rowId },
+    }));
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision,
+      description: `${objects.length} Revit-Objekte zugeordnet`,
+      command: createExternalObjectRowAssignmentProjectCommand({
+        rows: [{ expected: expectedRow, target: targetRow }],
+        objects,
+        confirmedConflictObjectIds,
+      }),
+    });
+    return res.json(result);
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+export async function detachExternalObjectsFromRow(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const objectIds = parseObjectIds(req.body?.objectIds);
+    const { state, projectExists } = externalModelStateRepository.getByProject(projectId);
+    if (!projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    const treeResult = await buildProjectCircuitTrees(projectId);
+    const byId = new Map(state.objects.map((object) => [object.id, object]));
+    const selected = objectIds.map((id) => {
+      const object = byId.get(id);
+      if (!object?.circuitDeviceRowId) throw new Error("Ein Revit-Objekt ist keiner Gerätezeile zugeordnet.");
+      return object;
+    });
+    const rowIds = new Set(selected.map((object) => object.circuitDeviceRowId!));
+    if (rowIds.size !== 1) throw new Error("Revit-Objekte können nur aus derselben Gerätezeile gemeinsam gelöst werden.");
+    const rowId = [...rowIds][0]!;
+    const location = findRow(treeResult, rowId);
+    if (!location) throw new Error("Gerätezeile wurde nicht gefunden.");
+    const expectedRow = toRowSnapshot(location.row, location.circuitId);
+    const removedQuantity = selected.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0);
+    const targetRow = { ...expectedRow, quantity: expectedRow.quantity - removedQuantity };
+    const copiedFields = ["displayName", "category", "connectionKind", "powerPerUnitW", "simultaneityFactor", "cosPhi", "costGroup", "remark"] as const;
+    const objects = selected.map((expected) => ({
+      expected,
+      target: {
+        ...expected,
+        circuitDeviceRowId: null,
+        distributionBoardId: location.distributionBoardId,
+        linkedProjectDeviceId: expectedRow.linkedProjectDeviceId,
+        planningValues: {
+          ...expected.planningValues,
+          displayName: expectedRow.displayName,
+          category: location.category,
+          connectionKind: expectedRow.connectionKind,
+          powerPerUnitW: expectedRow.powerPerUnit * 1000,
+          simultaneityFactor: expectedRow.simultaneityFactor,
+          cosPhi: expectedRow.cosPhi,
+          costGroup: expectedRow.costGroup,
+          remark: expectedRow.remark,
+        },
+        overriddenFields: [...new Set([...expected.overriddenFields, ...copiedFields])],
+      },
+    }));
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision,
+      description: `${objects.length} Revit-Objekte gelöst`,
+      command: createExternalObjectRowAssignmentProjectCommand({
+        rows: [{ expected: expectedRow, target: targetRow }],
+        objects,
+        confirmedConflictObjectIds: [],
+      }),
+    });
+    return res.json(result);
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+export async function assignExternalObjectsToNewRow(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const objectIds = parseObjectIds(req.body?.objectIds);
+    const circuitId = requiredId(req.body?.circuitId, "Ungültiger Stromkreis.");
+    const context = await loadAssignmentContext(projectId, objectIds);
+    const circuitLocation = context.treeResult?.trees.flatMap((tree) => tree.sections.flatMap((section) => section.circuits.map((circuit) => ({ tree, section, circuit })))).find((entry) => entry.circuit.id === circuitId);
+    if (!circuitLocation || !circuitLocation.section.category) throw new Error("Stromkreis wurde nicht gefunden.");
+    const row = buildExternalRow(context.objects, context.roomId, circuitId, Math.max(0, ...circuitLocation.circuit.deviceRows.map((entry) => entry.sortOrder)) + 10);
+    const transitions = context.objects.map((expected) => ({ expected, target: { ...expected, distributionBoardId: circuitLocation.tree.distributionBoardId, circuitDeviceRowId: row.id } }));
+    const result = projectCommandService.executeUser({ projectId, expectedRevision, description: `${transitions.length} Revit-Objekte als neue Gerätezeile zugeordnet`, command: createExternalObjectNewRowProjectCommand(externalObjectAssignToNewRowCommandType, { row, objects: transitions, confirmedConflictObjectIds: objectIds }) });
+    return res.json(result);
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+export async function assignExternalObjectsToNewCircuit(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const objectIds = parseObjectIds(req.body?.objectIds);
+    const sectionId = requiredId(req.body?.sectionId, "Ungültige Stromkreisgruppe.");
+    const context = await loadAssignmentContext(projectId, objectIds);
+    const sectionLocation = context.treeResult?.trees.flatMap((tree) => tree.sections.map((section) => ({ tree, section }))).find((entry) => entry.section.id === sectionId);
+    if (!sectionLocation?.section.category) throw new Error("Stromkreisgruppe wurde nicht gefunden.");
+    const circuitId = randomUUID();
+    const row = buildExternalRow(context.objects, context.roomId, circuitId, 10);
+    const protection = createDefaultCircuitProtection(sectionLocation.section.category);
+    const circuit = {
+      id: circuitId,
+      circuitListId: sectionLocation.tree.circuitListId,
+      sectionId,
+      equipmentIdentifier: await circuitNumberingService.getNextIdentifier(sectionId),
+      displayName: null,
+      sortOrder: Math.max(0, ...sectionLocation.section.circuits.map((entry) => entry.sortOrder)) + 10,
+      cableType: null, cableCrossSection: null, cableLength: null, rcdAssignment: null,
+      terminalDesignation: null,
+      voltage: sectionLocation.section.category === "three_phase" ? sectionLocation.tree.threePhaseVoltageV : sectionLocation.tree.singlePhaseVoltageV,
+      controlRequirement: null, status: null, isReserve: false, remark: null,
+      deviceRows: [row],
+      protectionDevice: {
+        circuitId,
+        type: protection.type,
+        ratedCurrentA: protection.ratedCurrentA,
+        fuseUtilizationCategory: "fuseUtilizationCategory" in protection ? protection.fuseUtilizationCategory : null,
+        tripCharacteristic: "tripCharacteristic" in protection ? protection.tripCharacteristic : null,
+        rcdType: "rcdType" in protection ? protection.rcdType : null,
+        ratedResidualCurrentMa: "ratedResidualCurrentMa" in protection ? protection.ratedResidualCurrentMa : null,
+      },
+    };
+    const transitions = context.objects.map((expected) => ({ expected, target: { ...expected, distributionBoardId: sectionLocation.tree.distributionBoardId, circuitDeviceRowId: row.id } }));
+    const result = projectCommandService.executeUser({ projectId, expectedRevision, description: `${transitions.length} Revit-Objekte als neuen Stromkreis zugeordnet`, command: createExternalObjectNewCircuitProjectCommand(externalObjectAssignToNewCircuitCommandType, { circuit, objects: transitions, confirmedConflictObjectIds: objectIds }) });
+    return res.json(result);
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+async function loadAssignmentContext(projectId: string, objectIds: string[]) {
+  const { state, projectExists } = externalModelStateRepository.getByProject(projectId);
+  if (!projectExists) throw new Error("Projekt nicht gefunden.");
+  const byId = new Map(state.objects.map((object) => [object.id, object]));
+  const objects = objectIds.map((id) => {
+    const object = byId.get(id);
+    if (!object) throw new Error("Ein Revit-Objekt wurde nicht gefunden.");
+    if (object.circuitDeviceRowId !== null) throw new Error("Ein Revit-Objekt ist bereits zugeordnet.");
+    return object;
+  });
+  const roomIds = new Set(objects.map((object) => object.externalRoomMappingId === null ? null : state.roomMappings.find((mapping) => mapping.id === object.externalRoomMappingId)?.roomId ?? null));
+  if (roomIds.size !== 1) throw new Error("Revit-Objekte aus verschiedenen Räumen benötigen getrennte Gerätezeilen.");
+  return { objects, roomId: [...roomIds][0]!, treeResult: await buildProjectCircuitTrees(projectId) };
+}
+
+function buildExternalRow(objects: ReturnType<typeof externalModelStateRepository.getByProject>["state"]["objects"], roomId: string | null, circuitId: string, sortOrder: number): CircuitDeviceRowSnapshot {
+  const first = objects[0]!;
+  const planning = first.planningValues;
+  const quantity = objects.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0);
+  return {
+    id: randomUUID(), circuitId, linkedProjectDeviceId: first.linkedProjectDeviceId,
+    sortOrder, name: first.acceptedSourceValues.familyAndType,
+    displayName: planning.displayName ?? (scalarText(first.acceptedSourceValues.selectionMarker) || first.acceptedSourceValues.familyAndType),
+    phaseType: planning.category === "three_phase" ? "three_phase" : "single_phase",
+    connectionKind: planning.connectionKind, costGroup: planning.costGroup,
+    category: planning.category, level: null,
+    roomId,
+    roomNumberSnapshot: scalarText(first.acceptedSourceValues.roomNumber) || null,
+    roomNameSnapshot: scalarText(first.acceptedSourceValues.roomName) || null,
+    quantity, manualQuantity: 0,
+    powerPerUnit: (planning.powerPerUnitW ?? 0) / 1000,
+    simultaneityFactor: planning.simultaneityFactor ?? 1,
+    cosPhi: planning.cosPhi, remark: planning.remark, overriddenFields: null,
+  };
+}
+
+function parseExpectedRevision(value: unknown) {
+  if (!Number.isSafeInteger(value) || (value as number) < 0) throw new Error("Ungültige Projektrevision.");
+  return value as number;
+}
+function parseObjectIds(value: unknown): string[] {
+  if (!Array.isArray(value) || value.length === 0) throw new Error("Keine Revit-Objekte ausgewählt.");
+  const ids = value.map((entry) => requiredId(entry, "Ungültige Revit-Objekt-ID."));
+  if (new Set(ids).size !== ids.length) throw new Error("Revit-Objekte sind doppelt ausgewählt.");
+  return ids;
+}
+function requiredId(value: unknown, message: string) { if (typeof value !== "string" || !value) throw new Error(message); return value; }
+function findRow(result: Awaited<ReturnType<typeof buildProjectCircuitTrees>>, rowId: string) {
+  if (!result) return null;
+  for (const tree of result.trees) for (const section of tree.sections) for (const circuit of section.circuits) {
+    const row = circuit.deviceRows.find((entry) => entry.id === rowId);
+    if (row) return { row, circuitId: circuit.id, distributionBoardId: tree.distributionBoardId, category: section.category ?? null };
+  }
+  return null;
+}
+function toRowSnapshot(row: NonNullable<ReturnType<typeof findRow>>["row"], circuitId: string): CircuitDeviceRowSnapshot {
+  return { id: row.id, circuitId, linkedProjectDeviceId: row.linkedProjectDeviceId ?? null, sortOrder: row.sortOrder, name: row.name, displayName: row.displayName, phaseType: row.phaseType ?? null, connectionKind: row.connectionKind ?? null, costGroup: row.costGroup ?? null, category: row.category ?? null, level: row.level ?? null, roomId: row.roomId ?? null, roomNumberSnapshot: row.roomNumberSnapshot ?? null, roomNameSnapshot: row.roomNameSnapshot ?? null, quantity: row.quantity, manualQuantity: row.manualQuantity, powerPerUnit: row.powerPerUnit, simultaneityFactor: row.simultaneityFactor, cosPhi: row.cosPhi ?? null, remark: row.remark ?? null, overriddenFields: row.overriddenFields ?? null };
+}
+
 const planningFields = ["displayName", "category", "connectionKind", "effectiveQuantity", "powerPerUnitW", "simultaneityFactor", "cosPhi", "costGroup", "remark"] as const satisfies readonly (keyof ExternalModelObjectPlanningValues)[];
 function scalarText(value: string | number | boolean | null) { return value === null ? "" : String(value); }
 function isRecord(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); }

src/server/controllers/external-return-workbook.controller.ts

@@ -0,0 +1,180 @@
+import { createHash, randomUUID } from "node:crypto";
+import type { Request, Response } from "express";
+import type { CircuitGroupCategory } from "../../shared/constants/circuit-group.js";
+import type { ExternalExportScope } from "../../db/schema/external-export-batches.js";
+import { projectExternalXlsxReturn, type ExternalReturnRowContext } from "../../external-model/application/external-xlsx-return-projection.js";
+import { createExternalXlsxReturn } from "../../external-model/xlsx/external-xlsx-transport.js";
+import {
+  externalExportBatchRepository,
+  externalModelStateRepository,
+  projectRepository,
+} from "../composition/application-repositories.js";
+import { buildProjectCircuitTrees } from "./circuit-tree.controller.js";
+
+const exportScopes = new Set<ExternalExportScope>(["all", "deviating", "selected"]);
+
+export async function createExternalReturnWorkbook(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const scope = parseScope(req.body?.scope);
+    const selectedObjectIds = scope === "selected" ? parseSelectedIds(req.body?.selectedObjectIds) : [];
+    if (scope === "selected" && selectedObjectIds.length === 0) {
+      return res.status(400).json({ error: "Für die ausgewählte Rückgabe wurden keine Revit-Objekte markiert." });
+    }
+
+    const project = await projectRepository.findById(projectId);
+    if (!project) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    if (project.currentRevision !== expectedRevision) {
+      return res.status(409).json({
+        error: "Die Rückgabe ist wegen einer neueren Projektrevision ungültig.",
+        code: "PROJECT_REVISION_CONFLICT",
+        expectedRevision,
+        currentRevision: project.currentRevision,
+      });
+    }
+
+    const { state } = externalModelStateRepository.getByProject(projectId);
+    const importBatch = state.importBatches.at(-1);
+    if (!importBatch?.originalContentBase64 || !importBatch.configurationSnapshot) {
+      return res.status(409).json({
+        error: "Für die Rückgabe fehlt der letzte vollständige Revit-Import.",
+        code: "EXTERNAL_XLSX_IMPORT_REQUIRED",
+      });
+    }
+    const treeResult = await buildProjectCircuitTrees(projectId);
+    if (!treeResult || treeResult.currentRevision !== expectedRevision) {
+      return res.status(409).json({
+        error: "Die Rückgabe ist wegen einer neueren Projektrevision ungültig.",
+        code: "PROJECT_REVISION_CONFLICT",
+      });
+    }
+
+    const rowById = new Map<string, ExternalReturnRowContext>();
+    for (const tree of treeResult.trees) {
+      for (const section of tree.sections) {
+        for (const circuit of section.circuits) {
+          for (const row of circuit.deviceRows) {
+            rowById.set(row.id, {
+              rowId: row.id,
+              displayName: row.displayName,
+              powerPerUnitKw: row.powerPerUnit,
+              cosPhi: row.cosPhi ?? null,
+              phaseType: row.phaseType ?? null,
+              category: (section.category ?? null) as CircuitGroupCategory | null,
+              circuitIdentifier: circuit.equipmentIdentifier,
+              circuitVoltageV: circuit.voltage ?? null,
+              distributionBoardName: tree.distributionBoardName,
+            });
+          }
+        }
+      }
+    }
+
+    const projections = state.objects
+      .filter((object) => object.presenceStatus === "present" && object.lastSeenImportBatchId === importBatch.id)
+      .map((object) => projectExternalXlsxReturn({
+        object,
+        row: object.circuitDeviceRowId ? rowById.get(object.circuitDeviceRowId) ?? null : null,
+        circuitMode: importBatch.configurationSnapshot!.circuitMode,
+        singlePhaseVoltageV: project.singlePhaseVoltageV,
+        threePhaseVoltageV: project.threePhaseVoltageV,
+      }));
+    const projectionById = new Map(projections.map((projection) => [projection.objectId, projection]));
+    for (const objectId of selectedObjectIds) {
+      if (!projectionById.has(objectId)) {
+        return res.status(400).json({ error: "Ein ausgewähltes Revit-Objekt gehört nicht zum letzten Import." });
+      }
+    }
+    const selected = scope === "all"
+      ? projections
+      : scope === "deviating"
+        ? projections.filter((projection) => projection.differsFromImported)
+        : selectedObjectIds.map((id) => projectionById.get(id)!);
+    if (selected.length === 0) {
+      return res.status(400).json({ error: "Der gewählte Rückgabeumfang enthält keine Revit-Objekte." });
+    }
+
+    const result = await createExternalXlsxReturn({
+      fileName: importBatch.fileName,
+      bytes: Buffer.from(importBatch.originalContentBase64, "base64"),
+      configuration: importBatch.configurationSnapshot,
+      selectedWorksharingIds: selected.map((projection) => projection.worksharingId),
+      updates: selected.map((projection) => ({
+        worksharingId: projection.worksharingId,
+        values: projection.values,
+      })),
+    });
+    const fileName = `${safeFileName(project.name)}_Revit-Rueckgabe_${new Date().toISOString().slice(0, 10)}.xlsx`;
+    const sha256 = hash(result.bytes);
+    const configurationSha256 = hash(Buffer.from(JSON.stringify(importBatch.configurationSnapshot), "utf8"));
+    const currentProject = await projectRepository.findById(projectId);
+    if (!currentProject || currentProject.currentRevision !== expectedRevision) {
+      return res.status(409).json({
+        error: "Die Rückgabe ist wegen einer neueren Projektrevision ungültig.",
+        code: "PROJECT_REVISION_CONFLICT",
+        expectedRevision,
+        currentRevision: currentProject?.currentRevision ?? null,
+      });
+    }
+    externalExportBatchRepository.append({
+      id: randomUUID(),
+      projectId,
+      projectRevision: expectedRevision,
+      importBatchId: importBatch.id,
+      exportedAtIso: new Date().toISOString(),
+      fileName,
+      sha256,
+      configurationSnapshot: importBatch.configurationSnapshot,
+      configurationSha256,
+      scope,
+      objectCount: result.exportedObjectCount,
+    });
+
+    const projectionWarnings = selected.flatMap((projection) =>
+      projection.warnings.map((warning) => `${projection.worksharingId}: ${warning}`)
+    );
+    return res.json({
+      fileName,
+      contentBase64: Buffer.from(result.bytes).toString("base64"),
+      sha256,
+      objectCount: result.exportedObjectCount,
+      warnings: [...new Set([...result.issues.map((issue) => issue.message), ...projectionWarnings])],
+    });
+  } catch (error) {
+    return res.status(400).json({ error: error instanceof Error ? error.message : "Revit-Rückgabe fehlgeschlagen." });
+  }
+}
+
+export async function listExternalExportBatches(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  const project = await projectRepository.findById(projectId);
+  if (!project) return res.status(404).json({ error: "Projekt nicht gefunden." });
+  return res.json(externalExportBatchRepository.listByProject(projectId).map(({ configurationSnapshot: _configuration, ...batch }) => batch));
+}
+
+function parseExpectedRevision(value: unknown) {
+  if (!Number.isSafeInteger(value) || (value as number) < 0) throw new Error("Ungültige Projektrevision.");
+  return value as number;
+}
+
+function parseScope(value: unknown): ExternalExportScope {
+  if (typeof value !== "string" || !exportScopes.has(value as ExternalExportScope)) throw new Error("Ungültiger Rückgabeumfang.");
+  return value as ExternalExportScope;
+}
+
+function parseSelectedIds(value: unknown) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string") || new Set(value).size !== value.length) {
+    throw new Error("Ungültige Objektauswahl.");
+  }
+  return value as string[];
+}
+
+function safeFileName(value: string) {
+  return value.trim().replace(/[<>:"/\\|?*\u0000-\u001f]/g, "_") || "Projekt";
+}
+
+function hash(bytes: Uint8Array) {
+  return createHash("sha256").update(bytes).digest("hex");
+}

src/server/routes/project.routes.ts

@@ -63,7 +63,8 @@ import {
   getExternalInitialImportStatus,
   planExternalInitialImport,
 } from "../controllers/external-initial-import.controller.js";
-import { listExternalObjects, updateExternalObjects } from "../controllers/external-objects.controller.js";
+import { assignExternalObjectsToNewCircuit, assignExternalObjectsToNewRow, assignExternalObjectsToRow, detachExternalObjectsFromRow, listExternalObjects, updateExternalObjects } from "../controllers/external-objects.controller.js";
+import { createExternalReturnWorkbook, listExternalExportBatches } from "../controllers/external-return-workbook.controller.js";
 
 export const projectRouter = Router();
 
@@ -93,6 +94,12 @@ projectRouter.post("/:projectId/external-model/initial-import/plan", planExterna
 projectRouter.post("/:projectId/external-model/initial-import/apply", applyExternalInitialImport);
 projectRouter.get("/:projectId/external-model/objects", listExternalObjects);
 projectRouter.put("/:projectId/external-model/objects", updateExternalObjects);
+projectRouter.post("/:projectId/external-model/objects/assign-row", assignExternalObjectsToRow);
+projectRouter.post("/:projectId/external-model/objects/assign-new-row", assignExternalObjectsToNewRow);
+projectRouter.post("/:projectId/external-model/objects/assign-new-circuit", assignExternalObjectsToNewCircuit);
+projectRouter.post("/:projectId/external-model/objects/detach-row", detachExternalObjectsFromRow);
+projectRouter.post("/:projectId/external-model/return-workbook", createExternalReturnWorkbook);
+projectRouter.get("/:projectId/external-model/export-batches", listExternalExportBatches);
 projectRouter.get("/:projectId/distribution-boards", listDistributionBoardsByProject);
 projectRouter.post("/:projectId/distribution-boards", createDistributionBoard);
 projectRouter.post(

tests/external-export-batch.repository.test.ts

@@ -0,0 +1,40 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { ExternalExportBatchRepository } from "../src/db/repositories/external-export-batch.repository.js";
+import { projects } from "../src/db/schema/projects.js";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
+
+describe("external export batch repository", () => {
+  it("appends immutable audit metadata without changing the project revision", () => {
+    const context = createDatabaseContext(":memory:");
+    try {
+      migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+      context.db.insert(projects).values({ id: "project-1", name: "Projekt", currentRevision: 7 }).run();
+      const repository = new ExternalExportBatchRepository(context.db);
+      const configuration = createDefaultExternalModelConfiguration();
+      repository.append({
+        id: "export-1", projectId: "project-1", projectRevision: 7,
+        importBatchId: "historical-import-without-foreign-key", exportedAtIso: "2026-09-30T10:00:00.000Z",
+        fileName: "Projekt_Revit-Rueckgabe_2026-09-30.xlsx", sha256: "a".repeat(64),
+        configurationSnapshot: configuration, configurationSha256: "b".repeat(64), scope: "all", objectCount: 4,
+      });
+      configuration.columns.designation = "Nachträglich geändert";
+      repository.append({
+        id: "export-2", projectId: "project-1", projectRevision: 7,
+        importBatchId: "historical-import-without-foreign-key", exportedAtIso: "2026-09-30T11:00:00.000Z",
+        fileName: "Projekt_Revit-Rueckgabe_2026-09-30.xlsx", sha256: "c".repeat(64),
+        configurationSnapshot: configuration, configurationSha256: "d".repeat(64), scope: "selected", objectCount: 1,
+      });
+
+      const batches = repository.listByProject("project-1");
+      assert.deepEqual(batches.map((batch) => batch.id), ["export-2", "export-1"]);
+      assert.notEqual(batches[0]!.configurationSnapshot.columns.designation, batches[1]!.configurationSnapshot.columns.designation);
+      assert.equal(context.db.select({ revision: projects.currentRevision }).from(projects).get()!.revision, 7);
+    } finally {
+      context.close();
+    }
+  });
+});

tests/external-object-row-assignment-project-command.repository.test.ts

@@ -7,6 +7,9 @@ import { createDatabaseContext, type AppDatabase } from "../src/db/database-cont
 import { ExternalObjectRowAssignmentProjectCommandRepository } from "../src/db/repositories/external-object-row-assignment-project-command.repository.js";
 import { ExternalObjectNewRowProjectCommandRepository } from "../src/db/repositories/external-object-new-row-project-command.repository.js";
 import { ExternalObjectNewCircuitProjectCommandRepository } from "../src/db/repositories/external-object-new-circuit-project-command.repository.js";
+import { CircuitDeviceRowStructureProjectCommandRepository } from "../src/db/repositories/circuit-device-row-structure-project-command.repository.js";
+import { CircuitStructureProjectCommandRepository } from "../src/db/repositories/circuit-structure-project-command.repository.js";
+import { CircuitGroupSubtreeProjectCommandRepository } from "../src/db/repositories/circuit-group-subtree-project-command.repository.js";
 import { toCircuitDeviceRowSnapshot } from "../src/db/repositories/circuit-device-row-structure.persistence.js";
 import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
 import { circuitLists } from "../src/db/schema/circuit-lists.js";
@@ -31,6 +34,10 @@ import {
   externalObjectAssignToNewCircuitCommandType,
 } from "../src/domain/models/external-object-new-circuit-project-command.model.js";
 import type { ExternalModelObjectSnapshot } from "../src/external-model/domain/external-model-contracts.js";
+import { createCircuitDeviceRowDeleteProjectCommand } from "../src/domain/models/circuit-device-row-structure-project-command.model.js";
+import { createCircuitDeleteProjectCommand } from "../src/domain/models/circuit-structure-project-command.model.js";
+import { createCircuitGroupDeleteSubtreeProjectCommand } from "../src/domain/models/circuit-group-subtree-project-command.model.js";
+import { assertDistributionBoardHasNoExternalObjects, assertRoomHasNoExternalObjects } from "../src/db/repositories/external-object-deletion-guard.persistence.js";
 
 function createFixture(initialObjectRowId: string | null = "row-1") {
   const context = createDatabaseContext(":memory:");
@@ -626,4 +633,63 @@ describe("external object new-circuit project command", () => {
       context.close();
     }
   });
+
+  it("detaches linked objects on row deletion and restores the exact link on undo", () => {
+    const context = createFixture();
+    try {
+      const repository = new CircuitDeviceRowStructureProjectCommandRepository(context.db);
+      const deleted = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createCircuitDeviceRowDeleteProjectCommand("row-1", "circuit-1"),
+      });
+      assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, null);
+      assert.equal(context.db.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, "row-1")).get(), undefined);
+
+      repository.execute({
+        projectId: "project-1",
+        expectedRevision: 1,
+        source: "undo",
+        historyTargetChangeSetId: deleted.revision.changeSetId,
+        command: deleted.inverse,
+      });
+      assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, "row-1");
+      assert.ok(context.db.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, "row-1")).get());
+    } finally {
+      context.close();
+    }
+  });
+
+  it("preserves external links through circuit and populated-group deletion undo", () => {
+    for (const kind of ["circuit", "group"] as const) {
+      const context = createFixture();
+      try {
+        const repository = kind === "circuit"
+          ? new CircuitStructureProjectCommandRepository(context.db)
+          : new CircuitGroupSubtreeProjectCommandRepository(context.db);
+        const command = kind === "circuit"
+          ? createCircuitDeleteProjectCommand("circuit-1", "list-1")
+          : createCircuitGroupDeleteSubtreeProjectCommand(
+              (repository as CircuitGroupSubtreeProjectCommandRepository).capture("project-1", "section-1")
+            );
+        const deleted = repository.execute({ projectId: "project-1", expectedRevision: 0, source: "user", command } as never);
+        assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, null);
+        repository.execute({ projectId: "project-1", expectedRevision: 1, source: "undo", historyTargetChangeSetId: deleted.revision.changeSetId, command: deleted.inverse } as never);
+        assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, "row-1");
+      } finally {
+        context.close();
+      }
+    }
+  });
+
+  it("blocks room and distribution-board deletion while external objects reference them", () => {
+    const context = createFixture(null);
+    try {
+      assert.throws(() => assertDistributionBoardHasNoExternalObjects(context.db, "project-1", "board-1"), /Revit-Objekte/);
+      assert.throws(() => assertRoomHasNoExternalObjects(context.db, "project-1", "room-1"), /Revit-Objekte/);
+    } finally {
+      context.close();
+    }
+  });
 });

tests/external-xlsx-return-projection.test.ts

@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { projectExternalXlsxReturn } from "../src/external-model/application/external-xlsx-return-projection.js";
+import type { ExternalModelObjectSnapshot } from "../src/external-model/domain/external-model-contracts.js";
+
+function object(): ExternalModelObjectSnapshot {
+  return {
+    id: "object-1", projectId: "project-1", sourceId: "source-1",
+    worksharingId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee-ffffffff", ifcGuid: null,
+    deviceTypeId: "type-1", lastSeenImportBatchId: "batch-1", lastAcceptedImportBatchId: "batch-1",
+    acceptedSourceValues: { rowNumber: 2, roomNumber: "101", roomName: "Büro", familyAndType: "Steckdose", selectionMarker: "SD", socketCount: 2, sourceRemark: null, circuitCombined: "UV 1-2F1.1", boardName: "UV 1", circuitIdentifier: "-2F1.1", designation: "Steckdose", electricalPowerW: "240", voltageV: 230, currentA: "1,16" },
+    planningValues: { displayName: "Steckdose", category: "single_phase", connectionKind: "socket", effectiveQuantity: 2, powerPerUnitW: 120, simultaneityFactor: 1, cosPhi: 0.9, costGroup: null, remark: null },
+    overriddenFields: [], externalRoomMappingId: null, distributionBoardId: "board-1", linkedProjectDeviceId: null, circuitDeviceRowId: "row-1", presenceStatus: "present",
+  };
+}
+
+describe("external XLSX return projection", () => {
+  it("projects typed row values and compares normalized imported scalars", () => {
+    const result = projectExternalXlsxReturn({ object: object(), circuitMode: "combined", singlePhaseVoltageV: 230, threePhaseVoltageV: 400, row: { rowId: "row-1", displayName: "Steckdose", powerPerUnitKw: 0.12, cosPhi: 0.9, phaseType: "single_phase", category: "single_phase", circuitIdentifier: "-2F1.1", circuitVoltageV: 230, distributionBoardName: "UV 1" } });
+    assert.deepEqual(result.values, { circuitCombined: "UV 1-2F1.1", designation: "Steckdose", electricalPowerW: 240, voltageV: 230, currentA: 1.16 });
+    assert.equal(result.differsFromImported, false);
+    assert.deepEqual(result.warnings, []);
+  });
+
+  it("uses object planning without a row and leaves an uncomputable current empty", () => {
+    const input = object(); input.circuitDeviceRowId = null; input.planningValues.cosPhi = null;
+    const result = projectExternalXlsxReturn({ object: input, row: null, circuitMode: "separate", singlePhaseVoltageV: 230, threePhaseVoltageV: 400 });
+    assert.equal(result.values.boardName, "");
+    assert.equal(result.values.circuitIdentifier, "");
+    assert.equal(result.values.electricalPowerW, 240);
+    assert.equal(result.values.currentA, null);
+    assert.equal(result.differsFromImported, true);
+    assert.match(result.warnings.join(" "), /Stromstärke/);
+  });
+
+  it("uses three-phase current and object-specific effective quantity", () => {
+    const input = object(); input.planningValues.category = "three_phase"; input.planningValues.effectiveQuantity = 3;
+    const result = projectExternalXlsxReturn({ object: input, row: null, circuitMode: "combined", singlePhaseVoltageV: 230, threePhaseVoltageV: 400 });
+    assert.equal(result.values.electricalPowerW, 360);
+    assert.equal(result.values.voltageV, 400);
+    assert.equal(result.values.currentA, 0.58);
+  });
+});

tests/revit-xlsx-settings-api.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { describe, it } from "node:test";
 import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
-import { applyExternalInitialImport, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getExternalProjectObjects, planExternalInitialImport, updateExternalModelConfiguration, updateExternalProjectObjects } from "../src/frontend/utils/api.js";
+import { applyExternalInitialImport, createExternalReturnWorkbook, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getExternalProjectObjects, planExternalInitialImport, updateExternalModelConfiguration, updateExternalProjectObjects } from "../src/frontend/utils/api.js";
 
 describe("Revit XLSX settings", () => {
   it("uses the project-scoped configuration endpoint with expectedRevision", async () => {
@@ -59,11 +59,15 @@ describe("Revit XLSX settings", () => {
     assert.match(revitPage, /Importstatus/);
     assert.match(settings, /Musterdatei prüfen/);
     assert.match(settings, /Kombinierte Stromkreisspalte/);
+    assert.match(settings, /isNewConfiguration/);
+    assert.match(revitPage, /isNewConfiguration={snapshot === null}/);
     assert.match(wizard, /Schritt.*von/);
     assert.match(wizard, /keine Gerätezeilen, Stromkreise oder BMKs/);
     assert.match(wizard, /GZF 1/);
     assert.match(objectTable, /viewportHeight/);
     assert.match(objectTable, /Sammeländerung anwenden/);
+    assert.match(objectTable, /Rückgabe-Excel herunterladen/);
+    assert.match(objectTable, /Nur geänderte Objekte/);
   });
 
   it("loads one project object list and sends revision-safe bulk updates", async () => {
@@ -74,4 +78,16 @@ describe("Revit XLSX settings", () => {
     finally { globalThis.fetch = originalFetch; }
     assert.deepEqual(requests, [{ url: "/api/projects/project-1/external-model/objects", method: "GET", body: undefined }, { url: "/api/projects/project-1/external-model/objects", method: "PUT", body: { expectedRevision: 4, objectIds: ["object-1"], patch: { simultaneityFactor: 0.7 } } }]);
   });
+
+  it("creates a revision-safe return workbook for the requested scope", async () => {
+    const requests: Array<{ url: string; method: string; body: unknown }> = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+      requests.push({ url: String(input), method: init?.method ?? "GET", body: init?.body ? JSON.parse(String(init.body)) : undefined });
+      return new Response(JSON.stringify({ fileName: "return.xlsx", contentBase64: "", sha256: "a".repeat(64), objectCount: 1, warnings: [] }), { status: 200, headers: { "Content-Type": "application/json" } });
+    };
+    try { await createExternalReturnWorkbook("project-1", 7, "selected", ["object-1"]); }
+    finally { globalThis.fetch = originalFetch; }
+    assert.deepEqual(requests, [{ url: "/api/projects/project-1/external-model/return-workbook", method: "POST", body: { expectedRevision: 7, scope: "selected", selectedObjectIds: ["object-1"] } }]);
+  });
 });