diff --git a/docs/data-links/design/data-links-post-design.md b/docs/data-links/design/data-links-post-design.md
new file mode 100644
index 000000000..e2de00052
--- /dev/null
+++ b/docs/data-links/design/data-links-post-design.md
@@ -0,0 +1,368 @@
+# Design: POST /data-links and POST /data-links/with-subsystems
+
+Requirements: [../requirements/data-links-post-requirements.md](../requirements/data-links-post-requirements.md)
+
+**Status:** APPROVED  
+**Date:** 2026-08-12
+
+---
+
+## 1. Architecture Overview
+
+Two separate endpoints, two separate command+handler pairs. Both share the same `DataLinkEditRepository` write port and `SubsystemDataLinkDerivationService` for traversal segment derivation.
+
+All writes go through `PendingChangeWriter.writeCreate()` into `edit_actions`, following the CREATE Spf Module pattern exactly (FR-DL-13, FR-DLS-12).
+
+```
+Controller
+  ├── POST /data-links              → CreateDataLinkFlatCommand    → CreateDataLinkFlatHandler
+  └── POST /data-links/with-subsystems → CreateDataLinkWithSubsystemsCommand → CreateDataLinkWithSubsystemsHandler
+
+Both handlers use:
+  - SubsystemRepository.getAllNodesWithParents()  (nodeParentMap load)
+  - SubsystemDataLinkDerivationService.compute()  (traversal segments)
+  - DataLinkEditRepository                        (write port, new)
+    └── PendingChangeWriter.writeCreate()         (edit_actions insertion)
+```
+
+`SubsystemDataLinkDerivationService` replaces `SubsystemBoundaryPathService`.
+The upload path uses the same descriptor output, preserving its traversal behavior.
+
+---
+
+## 2. New Commands and Request DTOs
+
+The stub `CreateDataLinkCommand` (with `type: 'normal' | 'EC' | 'interUsecase'`) is **replaced** by two new commands. All systemId fields are `string` (matching the requirements spec and project API convention).
+
+### 2.1 CreateDataLinkFlatCommand
+
+```
+packages/core/src/application/usecase-designer/data-links/create/
+  create-data-link-flat.command.ts
+  create-data-link-flat.handler.ts
+```
+
+```typescript
+class CreateDataLinkFlatCommand extends BaseCommand {
+  constructor(
+    readonly sourceModuleSystemId: string,
+    readonly sourcePortSystemId: string,
+    readonly destinationModuleSystemId: string,
+    readonly destinationPortSystemId: string,
+    readonly isInterUsecase?: boolean,
+    readonly isEc?: boolean,
+  )
+}
+```
+
+### 2.2 CreateDataLinkWithSubsystemsCommand
+
+```
+packages/core/src/application/usecase-designer/data-links/create/
+  create-data-link-with-subsystems.command.ts
+  create-data-link-with-subsystems.handler.ts
+```
+
+```typescript
+class CreateDataLinkWithSubsystemsCommand extends BaseCommand {
+  constructor(
+    readonly sourceNodeSystemId: string,
+    readonly sourcePortSystemId: string,
+    readonly destinationNodeSystemId: string,
+    readonly destinationPortSystemId: string,
+    readonly isInterUsecase?: boolean,
+    readonly isEc?: boolean,
+  )
+}
+```
+
+### 2.3 Request DTOs (packages/api)
+
+`CreateDataLinkFlatRequest` — fields match FR-DL-01; all systemId fields `@IsString()`.  
+`CreateDataLinkWithSubsystemsRequest` — fields match FR-DLS-01; all systemId fields `@IsString()`.
+
+The existing `CreateDataLinkRequest` (with `type` enum) is removed.
+
+---
+
+## 3. Query Extension — SubsystemRepository
+
+New method added to the `SubsystemRepository` core port and its TypeORM adapter:
+
+```typescript
+// packages/core/src/application/ports/persistence/repositories/subsystem/subsystem.repository.ts
+interface SubsystemRepository {
+  subsystemExists(systemId: number, fileSystemId: number): Promise<boolean>;
+
+  /** Returns a map of all node systemIds → parentId (or null if top-level) for the given file.
+   *  Covers both subsystem nodes and module nodes.
+   *  Used by handlers to construct the nodeParentMap for SubsystemDataLinkDerivationService. */
+  getAllNodesWithParents(fileSystemId: number): Promise<Map<number, number | null>>;
+}
+```
+
+**TypeORM adapter** (`TypeOrmSubsystemRepository`) queries the `nodes` table with `file_system_id = fileSystemId`, returning `system_id` and `parent_id` for all rows. The `parent_id` column is nullable.
+
+---
+
+## 4. Write Port — DataLinkEditRepository
+
+### 4.1 Core port
+
+```
+packages/core/src/application/ports/persistence/repositories/data-link/data-link-edit.repository.ts
+```
+
+```typescript
+export interface DataLinkEditRepository {
+  /**
+   * Writes CREATE edit_action rows for the DataLink, all its SubsystemDataLinks,
+   * and all auto-created boundary DataPorts. All rows share the groupId from
+   * the WriteContext stamped by CommandBus.
+   */
+  createDataLink(dataLink: DataLink, options?: EditOptions): Promise<void>;
+
+  /**
+   * Finds a DataLink in the session overlay by (sourcePortSystemId, destinationPortSystemId).
+   * Checks base data_links table + active CREATE/DELETE edit_action overlay.
+   * Returns null if not found at all.
+   * Returns {systemId, isDeleted: true, payload} if a DELETE edit_action exists.
+   * Returns {systemId, isDeleted: false, payload} if active (base or staged CREATE).
+   */
+  findByPortPair(
+    sourcePortSystemId: number,
+    destPortSystemId: number,
+    fileSystemId: number,
+  ): Promise<{systemId: number; isDeleted: boolean; payload: Record<string, unknown>} | null>;
+
+  /**
+   * Re-activates a soft-deleted DataLink (FR-DL-07a).
+   * Supersedes the current DELETE edit_action row, then inserts a new CREATE row
+   * with the provided payload. The new CREATE gets a fresh groupId from WriteContext.
+   */
+  reactivateDataLink(
+    systemId: number,
+    aggregateId: number,
+    payload: Record<string, unknown>,
+    options?: EditOptions,
+  ): Promise<void>;
+}
+```
+
+### 4.2 UnitOfWork extension
+
+`UnitOfWork` gets a new method:
+```typescript
+getDataLinkEditRepository(): DataLinkEditRepository;
+```
+
+### 4.3 TypeORM adapter
+
+```
+packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/data-link/data-link-edit.repository.ts
+```
+
+- `createDataLink()` calls `writer.writeCreate()` for each entity in this order:
+  1. One `Node` CREATE row per auto-created boundary DataPort (targetTable=`Node`)
+  2. One `DataPort` CREATE row per auto-created boundary port (targetTable=`DataPort`)
+  3. One `DataLink` CREATE row (targetTable=`DataLink`)
+  4. One `SubsystemDataLink` CREATE row per SLS segment (targetTable=`SubsystemDataLink`)
+  - All share the same `sessionId`, `groupId`, `aggregateId = dataLink.systemId`
+
+- `findByPortPair()` queries `data_links` table first, then checks `edit_actions` overlay for CREATE/DELETE in the session.
+
+- `reactivateDataLink()`:
+  1. `supersedeCurrent(sessionId, systemId, null, manager)` — stamps `valid_until` on the existing DELETE row
+  2. `writer.writeCreate({targetTable: 'DataLink', targetSystemId: systemId, aggregateId: systemId, payload})` — inserts new CREATE row
+
+---
+
+## 5. Handlers
+
+### 5.1 CreateDataLinkFlatHandler
+
+```
+packages/core/src/application/usecase-designer/data-links/create/create-data-link-flat.handler.ts
+```
+
+Orchestration (all within one transaction):
+
+1. `uow.startTransaction()`
+2. Get `{session, groupId}` from `uow.getWriteContext()`; extract `fileSystemId`
+3. Parse string IDs → numbers
+4. **Validation:**
+   - Nodes exist and are module-type nodes (FR-DL-02, FR-DL-03)
+   - Source ≠ dest (FR-DL-06)
+   - Source port is OUTPUT, dest port is INPUT; ports belong to their respective modules (FR-DL-04, FR-DL-05)
+5. **Duplicate check** via `dataLinkEditRepo.findByPortPair(srcPort, dstPort, fileSystemId)`:
+   - Active link → throw `409 Conflict`
+   - Soft-deleted → re-activate path (see §5.1a)
+   - Not found → proceed with create
+6. **linkType derivation** (FR-DL-09): load source/dest module's `subgraphSystemId`, derive `INTRA_SUBGRAPH` / `INTRA_USECASE` / `INTER_USECASE`. Validate `isEc` constraint (FR-DL-10).
+7. **nodeParentMap** load via `subsystemRepo.getAllNodesWithParents(fileSystemId)` (FR-DL-11)
+8. **Segment derivation**: `SubsystemDataLinkDerivationService.compute({sourceNodeSystemId, destinationNodeSystemId, nodeParentMap})`
+9. If `segments.length > 0` (cross-subsystem traversal):
+   - For each descriptor endpoint with a non-null boundary port type: allocate a boundary DataPort systemId with that `portIoType`
+   - For each descriptor: construct the corresponding `SubsystemDataLink` using its source and destination node IDs
+10. Construct `DataLink` domain object with all SLS attached
+11. `dataLinkEditRepo.createDataLink(dataLink)` — writes all `edit_actions` with shared `groupId`
+12. `uow.commit()`
+13. Return `UseCaseComponentsReadModel` with `dataLinks: [DataLinkReadModel]`
+
+**§5.1a Re-activation path (FR-DL-07a):** Skip create; derive fresh SLS chain (steps 7–10); call `dataLinkEditRepo.reactivateDataLink(systemId, aggregateId, payload)` for the DataLink; then write fresh SLS + boundary port CREATE rows. All share the same `groupId`.
+
+### 5.2 CreateDataLinkWithSubsystemsHandler
+
+```
+packages/core/src/application/usecase-designer/data-links/create/create-data-link-with-subsystems.handler.ts
+```
+
+**Branch A — Both endpoints are modules (FR-DLS-10):**
+- Same validation as flat handler (ports, directions, no self-loop, no duplicate)
+- Same linkType derivation, SLS traversal, DataLink creation
+- DataLink is written to `edit_actions` (persisted) but is **not** included in the response
+- Response: `UseCaseComponentsWithSubsystemsReadModel(subsystemDataLinks, autoCreatedDataPorts)`
+
+**Branch B — At least one endpoint is a subsystem (FR-DLS-11):**
+- Validate `isInterUsecase` and `isEc` are absent (FR-DLS-11 last para)
+- Validate port exists; validate subsystem port occupancy (FR-DLS-07); validate portIoType (FR-DLS-08)
+- Allocate one SLS systemId; no DataLink created
+- Construct one `SubsystemDataLink` with `dataLinkSystemId = null`
+- Write one `SubsystemDataLink` CREATE edit_action
+- Response: `UseCaseComponentsWithSubsystemsReadModel(subsystemDataLinks: [sls], autoCreatedDataPorts: [])`
+
+**Node type detection:** a node is a subsystem if it exists in the `subsystems` table (overlay-aware). Query via `subsystemRepo.subsystemExists()`.
+
+---
+
+## 6. Read Models
+
+### 6.1 SubsystemDataLinkReadModel (new)
+
+```
+packages/core/src/application/ports/persistence/query-services/usecase/query-models/subsystem-data-link-read-model.ts
+```
+
+```typescript
+interface SubsystemDataLinkReadModel {
+  systemId: number;
+  sourceNodeSystemId: number;
+  destinationNodeSystemId: number;
+  sourcePortSystemId: number;
+  destinationPortSystemId: number;
+  dataLinkSystemId: number | null;
+}
+```
+
+### 6.2 UseCaseComponentsWithSubsystemsReadModel (new)
+
+```
+packages/core/src/application/ports/persistence/query-services/usecase/query-models/usecase-components-with-subsystems-read-model.ts
+```
+
+```typescript
+class UseCaseComponentsWithSubsystemsReadModel {
+  constructor(
+    readonly subsystemDataLinks: SubsystemDataLinkReadModel[],
+    readonly autoCreatedDataPorts: DataPortReadModel[],
+  )
+}
+```
+
+Constructed directly by the handler from the domain objects — no additional DB read needed.
+
+---
+
+## 7. API Layer Changes
+
+### 7.1 Controller updates
+
+`DataLinkController`:
+- `createDataLink()` instantiates `CreateDataLinkFlatCommand` from `CreateDataLinkFlatRequest`
+- `createDataLinkWithSubsystems()` instantiates `CreateDataLinkWithSubsystemsCommand` from `CreateDataLinkWithSubsystemsRequest`
+- `toComponentCollectionDto()` maps `UseCaseComponentsReadModel` (unchanged)
+- `toComponentCollectionWithSubsystemsDto()` maps `UseCaseComponentsWithSubsystemsReadModel` → populates `subsystems = []`, populates `dataLinks = []`, and maps SLS to a new `SubsystemDataLinkDto`
+
+### 7.2 New DTOs (packages/api)
+
+`SubsystemDataLinkDto` — maps from `SubsystemDataLinkReadModel`.  
+`CreateDataLinkFlatRequest` — replaces `CreateDataLinkRequest`.  
+`CreateDataLinkWithSubsystemsRequest` — new.
+
+### 7.3 Command registry update
+
+`CommandHandlerRegistry` is updated to register:
+- `CreateDataLinkFlatCommand` → `CreateDataLinkFlatHandler`
+- `CreateDataLinkWithSubsystemsCommand` → `CreateDataLinkWithSubsystemsHandler`
+
+The old `CreateDataLinkCommand` → `CreateDataLinkHandler` registration is removed.
+
+---
+
+## 8. File and Port Scaffolding
+
+**Existing files modified:**
+- `packages/core/src/application/ports/persistence/repositories/subsystem/subsystem.repository.ts` — add `getAllNodesWithParents()`
+- `packages/core/src/application/ports/persistence/unit-of-work.ts` — add `getDataLinkEditRepository()`
+- `packages/core/src/application/orchestration/cqrs/registries/command-handler-registry.ts` — update registrations
+- `packages/api/src/infrastructure-wrapper/persistence/unit-of-work/typeorm-unit-of-work.ts` — implement `getDataLinkEditRepository()`
+- `packages/api/src/presentation/rest/modules/data-link/data-link.controller.ts` — update to new commands and DTOs
+- Subsystem repository TypeORM adapter — add `getAllNodesWithParents()`
+
+**New files:**
+- Core commands × 2
+- Core handlers × 2
+- Core read models × 2 (`SubsystemDataLinkReadModel`, `UseCaseComponentsWithSubsystemsReadModel`)
+- Core port: `data-link-edit.repository.ts`
+- Persistence adapter: `data-link-edit.repository.ts` (TypeORM implementation)
+- Persistence adapter: extend `typeorm-subsystem.repository.ts`
+- API: `CreateDataLinkFlatRequest`, `CreateDataLinkWithSubsystemsRequest`, `SubsystemDataLinkDto`
+
+**Deleted files:**
+- `packages/core/src/application/usecase-designer/data-links/create/create-data-link.command.ts` (replaced)
+- `packages/core/src/application/usecase-designer/data-links/create/create-data-link.handler.ts` (replaced)
+- `packages/api/src/presentation/rest/modules/data-link/dto/request/create-data-link-request.dto.ts` (replaced)
+
+---
+
+## 9. Requirements–Design Alignment Check
+
+| Requirement | Design Element |
+|---|---|
+| FR-DL-01 — endpoint + request body | §2.1, §7.1 |
+| FR-DL-02 — module-only validation | §5.1 step 4 |
+| FR-DL-03 — node/port existence | §5.1 step 4 |
+| FR-DL-04 — port direction | §5.1 step 4 |
+| FR-DL-05 — port ownership | §5.1 step 4 |
+| FR-DL-06 — no self-loops | §5.1 step 4 |
+| FR-DL-07 — duplicate 409 | §5.1 step 5 |
+| FR-DL-07a — soft-delete re-activation | §5.1a, §4.1 reactivateDataLink |
+| FR-DL-08 — subgraph IDs server-derived | §5.1 step 6 |
+| FR-DL-09 — linkType derivation | §5.1 step 6 |
+| FR-DL-10 — EC flag constraint | §5.1 step 6 |
+| FR-DL-11 — subsystem boundary traversal | §5.1 steps 7–9 |
+| FR-DL-12 — flat response | §6, §7.1 |
+| FR-DL-13 — persistence via edit_actions | §4.3 |
+| FR-DLS-01–09 — subsystem endpoint validation | §5.2 |
+| FR-DLS-10 — both modules: full traversal | §5.2 Branch A |
+| FR-DLS-11 — subsystem endpoint: single SLS | §5.2 Branch B |
+| FR-DLS-12 — edit_actions persistence | §4.3 |
+| FR-DLS-14 — subsystem response | §6.2, §7.1 |
+| FR-SVC-01–04 — derivation service replacement | §1, §5.1 steps 8-9 |
+| I1–I10 — invariants | enforced in handler validations §5.1/5.2 |
+
+---
+
+## 10. Verification
+
+1. Run unit tests in `packages/core/tests/unit/application/usecase-designer/data-links/`
+2. Run integration tests in `packages/infrastructure/persistence/tests/integration/repositories/data-link/`
+3. Run E2E tests in `packages/api/tests/e2e/` covering:
+   - Happy path flat: POST /data-links with module endpoints, no cross-subsystem
+   - Happy path flat: POST /data-links with cross-subsystem (SLS auto-created)
+   - Happy path subsystem: POST /data-links/with-subsystems both modules
+   - Happy path subsystem: POST /data-links/with-subsystems with one subsystem endpoint
+   - Re-activation: POST after DELETE for same port pair
+   - 409: POST for duplicate active link
+   - 422: wrong port direction, wrong port ownership, subsystem where module expected, etc.
+   - 404: non-existent node/port
diff --git a/docs/data-links/requirements/data-links-post-requirements.md b/docs/data-links/requirements/data-links-post-requirements.md
new file mode 100644
index 000000000..662b8630f
--- /dev/null
+++ b/docs/data-links/requirements/data-links-post-requirements.md
@@ -0,0 +1,290 @@
+# Requirements: POST /data-links and POST /data-links/with-subsystems
+
+**Feature folder:** `docs/data-links/`
+**Status:** APPROVED
+**Date:** 2026-08-08
+
+---
+
+## Context
+
+Two new write endpoints for managing data-links in the AudioReach usecase designer. The `POST /data-links` handler currently throws "Not implemented". The upload path already contains subsystem-boundary-crossing logic (`SubsystemBuilder.attachBoundaryPorts()` using `SubsystemBoundaryPathService`) that must be extracted into a shared domain service so both upload and the new APIs reuse it.
+
+---
+
+## Definitions
+
+| Term | Meaning |
+|---|---|
+| DataLink | A resolved module-to-module link stored in `data_links`. Has source+dest module endpoints and optional SLS chain. |
+| SLS / SubsystemDataLink | A single directed hop in `subsystem_data_links`. May be resolved (has `dataLinkSystemId`) or unresolved (`dataLinkSystemId = null`). |
+| Boundary port | A subsystem data port with `portIoType = InputOutput` (entry) or `OutputInput` (exit). Auto-created when traversing subsystem boundaries. |
+| Flat mode | Caller sees only DataLinks and module-level ports; SLS are internal. |
+| Subsystem mode | Caller sees SLS chain including subsystem nodes and boundary ports. |
+| nodeParentMap | A `Map<nodeSystemId, parentSystemId | null>` covering all nodes in a file, used by the path service. |
+
+---
+
+## Functional Requirements — POST /data-links (flat mode)
+
+### FR-DL-01 — Endpoint definition
+
+`POST /arc-api/v1/projects/:projectId/data-links`
+
+Request body:
+
+```
+{
+  sourceModuleSystemId:    string        // must be a module node
+  sourcePortSystemId:      string        // must be OUTPUT port, must belong to source node
+  destinationModuleSystemId: string      // must be a module node
+  destinationPortSystemId: string        // must be INPUT port, must belong to dest node
+  isInterUsecase?:         boolean       // if true → INTER_USECASE; server derives INTRA_SUBGRAPH vs INTRA_USECASE otherwise
+  isEc?:                   boolean       // optional; only valid when derived linkType is INTRA_USECASE
+}
+```
+
+### FR-DL-02 — Module-only endpoints
+
+`sourceModuleSystemId` and `destinationModuleSystemId` must both be module-type nodes. If either is a subsystem node → `422`.
+
+### FR-DL-03 — Node and port existence
+
+All provided node and port IDs must exist in the session's file. Return `404` if any are not found.
+
+### FR-DL-04 — Port direction validation
+
+- `sourcePortSystemId` must have `portIoType = OUTPUT`. → `422` if not.
+- `destinationPortSystemId` must have `portIoType = INPUT`. → `422` if not.
+
+### FR-DL-05 — Port ownership validation
+
+`sourcePortSystemId` must belong to `sourceModuleSystemId`. `destinationPortSystemId` must belong to `destinationModuleSystemId`. → `422` on mismatch.
+
+### FR-DL-06 — No self-loops
+
+`sourceModuleSystemId ≠ destinationModuleSystemId`. → `422` if equal.
+
+### FR-DL-07 — Duplicate DataLink check
+
+If a non-deleted DataLink already exists in the session with the same `(sourcePortSystemId, destinationPortSystemId)` pair → `409 Conflict`.
+
+### FR-DL-07a — Soft-deleted link re-activation
+
+If a **soft-deleted** DataLink exists with the same `(sourcePortSystemId, destinationPortSystemId)` pair, the server shall re-activate it (restore `deleted = false`) rather than creating a new record.
+
+Any SLS associated with the soft-deleted DataLink are **not** re-activated. The server derives a fresh SLS chain from the current graph topology following FR-DL-11. New SLS and boundary ports are created with fresh system IDs and grouped with the re-activated DataLink under a single `groupId`.
+
+### FR-DL-08 — Subgraph IDs are server-derived
+
+The server reads `sourceSubgraphSystemId` from the source module entity and `destSubgraphSystemId` from the dest module entity. These are never provided by the caller.
+
+### FR-DL-09 — linkType derivation
+
+The server derives the internal `linkType` from `isInterUsecase` and the subgraph IDs of the source and dest modules:
+
+- If `isInterUsecase = true` → derived `linkType = INTER_USECASE`. The server validates that the source and dest subgraphs belong to **different** usecases; otherwise → `422`.
+- If `isInterUsecase` is absent or `false`:
+  - `sourceSubgraph == destSubgraph` → `INTRA_SUBGRAPH`
+  - `sourceSubgraph ≠ destSubgraph` → `INTRA_USECASE`
+
+The caller never supplies `linkType` directly. `linkType` is an internal server concept used for persistence.
+
+### FR-DL-10 — EC flag constraint
+
+`isEc` is allowed only when the derived `linkType = INTRA_USECASE`. If provided when the derived `linkType` is `INTRA_SUBGRAPH` or `INTER_USECASE` → `422`.
+
+If `isEc` is omitted for an `INTRA_USECASE` link, the server persists `false`. `isEc` is `NULL` for `INTRA_SUBGRAPH` and `INTER_USECASE` links.
+
+### FR-DL-11 — Subsystem boundary traversal (inline SLS creation)
+
+When source and dest modules have different subsystem contexts (different `parentId` in the node hierarchy), the server must:
+
+1. Load a `nodeParentMap` by querying **all nodes in the file** in a single query.
+2. Invoke `SubsystemDataLinkDerivationService` (see FR-SVC-01–04) to compute the traversal path and segment descriptors.
+3. Allocate new system IDs and auto-create boundary ports at each traversal boundary node.
+4. Construct and persist all SLS segments and boundary ports atomically with the DataLink in the same unit of work, sharing a single `groupId`.
+
+If source and dest modules share the same subsystem context, no SLS are created.
+
+### FR-DL-12 — Response
+
+Returns `ComponentCollectionDto` containing the created DataLink. SLS and boundary ports are **not** included in the response.
+
+### FR-DL-13 — Persistence via edit-actions
+
+All creates (DataLink, SLS, boundary ports) are written to `edit_actions` with `operation = CREATE`, `source = MANUAL`, `changeStatus = STAGED`, sharing a single `groupId`.
+
+---
+
+## Functional Requirements — POST /data-links/with-subsystems (subsystem mode)
+
+### FR-DLS-01 — Endpoint definition
+
+`POST /arc-api/v1/projects/:projectId/data-links/with-subsystems`
+
+Request body:
+
+```
+{
+  sourceNodeSystemId:      string         // module or subsystem node
+  sourcePortSystemId:      string         // required for all endpoint types
+  destinationNodeSystemId: string         // module or subsystem node
+  destinationPortSystemId: string         // required for all endpoint types
+  isInterUsecase?:         boolean        // only meaningful when both endpoints are modules; if true → INTER_USECASE
+  isEc?:                   boolean        // only meaningful when both endpoints are modules and derived linkType is INTRA_USECASE
+}
+```
+
+### FR-DLS-02 — Port required for all endpoints
+
+`sourcePortSystemId` and `destinationPortSystemId` are always required regardless of node type. → `422` if either is absent.
+
+### FR-DLS-03 — Node and port existence
+
+All provided node and port IDs must exist in the session's file. → `404` if any are not found.
+
+### FR-DLS-04 — No self-loops
+
+`sourceNodeSystemId ≠ destinationNodeSystemId`. → `422` if equal.
+
+### FR-DLS-05 — Module port direction validation
+
+Same as FR-DL-04: source module port must be `OUTPUT`; dest module port must be `INPUT`.
+
+### FR-DLS-06 — Module port ownership validation
+
+Same as FR-DL-05: port must belong to the given module node.
+
+### FR-DLS-07 — Subsystem port occupancy check
+
+If caller provides `sourcePortSystemId` for a **subsystem** source node, that port must not already be the **source** of a non-deleted SLS in the session. → `422` if occupied.
+If caller provides `destinationPortSystemId` for a **subsystem** dest node, that port must not already be the **destination** of a non-deleted SLS in the session. → `422` if occupied.
+
+### FR-DLS-08 — Subsystem port type validation
+
+If caller provides a subsystem port, the server loads the port's `portIoType` and validates:
+
+- Source-side subsystem port → must be `InputOutput`. → `422` if not.
+- Dest-side subsystem port → must be `OutputInput`. → `422` if not.
+
+### FR-DLS-10 — Topology: both endpoints are modules
+
+If both source and destination are module nodes, the handler performs the same logic as FR-DL-11 (full boundary traversal + DataLink + SLS creation). The DataLink is created and persisted internally but is not included in the response (the subsystem-mode client renders SLS segments, not DataLinks). The response includes the SLS chain and any auto-created boundary ports.
+
+### FR-DLS-11 — Topology: at least one endpoint is a subsystem (single-hop unresolved SLS)
+
+If at least one endpoint is a subsystem node, the server creates **one unresolved SLS** between the two endpoints (`dataLinkSystemId = null`). No DataLink is created. The SLS records:
+
+- `sourceNodeSystemId` and `destinationNodeSystemId` as provided.
+- `sourcePortSystemId`: as provided by the caller.
+- `destinationPortSystemId`: as provided by the caller.
+
+If `isInterUsecase` or `isEc` is provided when at least one endpoint is a subsystem node → `422`. These fields are only meaningful for module-to-module links.
+
+### FR-DLS-12 — Persistence via edit-actions
+
+Same pattern as FR-DL-13. All creates (SLS, auto-created ports, optionally DataLink) share a `groupId`.
+
+### FR-DLS-14 — Response
+
+Returns `ComponentCollectionWithSubsystemsDto`:
+
+- **Both endpoints are modules (resolved):** `dataLinks` is empty; SLS chain and any auto-created boundary ports are included. The DataLink is created and persisted internally but excluded from the response — the subsystem-mode client renders SLS segments, not DataLinks.
+- **At least one subsystem endpoint (unresolved):** `dataLinks` is empty; the single SLS and any auto-created port are included.
+
+---
+
+## Functional Requirements — Shared Domain Service
+
+### FR-SVC-01 — Extract and name
+
+`SubsystemBoundaryPathService` is **replaced** by a new pure domain service named `SubsystemDataLinkDerivationService`. The old service and its exported `PathInput`/`PathOutput` interfaces are deleted.
+
+All callers of `SubsystemBoundaryPathService.compute()` — currently only `SubsystemBuilder.attachBoundaryPorts()` — are migrated to the new service API (see FR-SVC-04). The new service no longer takes `sourcePortId`/`destPortId` as inputs; they are not needed for path computation and are dropped.
+
+### FR-SVC-02 — Inputs and outputs (pure function contract)
+
+```
+Input:
+  sourceNodeId:  number
+  destNodeId:    number
+  nodeParentMap: Map<number, number | null>   // all nodes in file: systemId → parentId|null
+
+Output:
+  Array<{
+    sourceNodeId:           number
+    destNodeId:             number
+    sourceBoundaryPortType: PortIoType | null  // null if module endpoint
+    destBoundaryPortType:   PortIoType | null  // null if module endpoint
+    position:               number             // 0-based index in the chain
+  }>
+  // Empty array if source and dest share the same subsystem context.
+```
+
+### FR-SVC-03 — Pure function, no I/O
+
+The service performs no DB lookups, ID allocations, or network calls. Port system IDs and new entity system IDs are allocated and assigned by the calling handler.
+
+### FR-SVC-04 — Upload path refactored
+
+`SubsystemBuilder.attachBoundaryPorts()` is refactored to delegate to `SubsystemDataLinkDerivationService`. Upload behavior must not change — this is a pure code-movement refactor.
+
+---
+
+## Decisions
+
+The following design decisions were made during requirements review (2026-08-08):
+
+| # | Decision | Rationale |
+|---|---|---|
+| D1 | Duplicate DataLink uniqueness key is `(sourcePortSystemId, destinationPortSystemId)` only — `parentId` is not part of the key. | A port pair is globally unique in the graph regardless of subsystem parent context. |
+| D2 | EC link auto-detection (auto-deriving `isEcLink=true` from GKV membership) is dropped. `isEc` is purely caller-controlled. | Simplifies server logic; caller has full context of the use case type. |
+| D3 | If an INTRA_USECASE link is POSTed where an INTER_USECASE link already exists for the same `(sourcePort, destPort)` pair, the server rejects with `409`. | A port pair is a unique signal path; conflicting linkType is a caller error, not a silent upgrade. |
+| D4 | When a soft-deleted DataLink exists with the same `(sourcePort, destPort)` pair, re-activate it rather than creating a new record. | Avoids duplicate rows; preserves the original entity's history and system ID. |
+
+---
+
+## Out of Scope
+
+- **Subgraph pair creation** (`use_case_subgraph_pairs`) — deferred; not created by these APIs.
+- **Chain resolution** (converting complete unresolved SLS chains into DataLinks) — handled at commit/flatten time.
+- **DELETE /data-links** — separate feature.
+- **Control links** — separate feature.
+- **Orphaned subsystem port cleanup** — handled at commit time, not triggered by creation.
+
+---
+
+## Invariants
+
+| # | Invariant |
+|---|---|
+| I1 | DataLink source and dest must be module nodes (not subsystems). |
+| I2 | Source port must be OUTPUT; destination port must be INPUT (for module endpoints). |
+| I3 | Source-side boundary port must be `InputOutput`; dest-side must be `OutputInput`. |
+| I4 | No two non-deleted DataLinks can share the same `(sourcePort, destPort)` pair. |
+| I5 | A subsystem boundary port can be the source of at most one non-deleted SLS per file. |
+| I6 | A subsystem boundary port can be the destination of at most one non-deleted SLS per file. |
+| I7 | `isEc` is only valid on `INTRA_USECASE` DataLinks. |
+| I8 | `INTRA_SUBGRAPH` requires source and dest in the same subgraph. |
+| I9 | `INTER_USECASE` requires source and dest subgraphs in different usecases. |
+| I10 | `isEc` defaults to `false` when omitted on `INTRA_USECASE` DataLinks. It is `NULL` on `INTRA_SUBGRAPH` and `INTER_USECASE`. |
+
+---
+
+## Error Codes Summary
+
+| Scenario | HTTP Code |
+|---|---|
+| Node or port not found | 404 |
+| Node is wrong type (subsystem where module expected, or vice versa) | 422 |
+| Port required but absent (module endpoint without portSystemId) | 422 |
+| Port does not belong to node | 422 |
+| Port has wrong direction | 422 |
+| Subsystem port already occupied | 422 |
+| Subsystem port has wrong portIoType for position | 422 |
+| Self-loop (source == dest node) | 422 |
+| `isInterUsecase=true` but source and dest subgraphs belong to the same usecase | 422 |
+| `isEc` provided when derived linkType is not `INTRA_USECASE` | 422 |
+| `isInterUsecase` or `isEc` provided when a subsystem endpoint is involved | 422 |
+| Duplicate DataLink (same port pair exists and is not deleted) | 409 |
diff --git a/packages/api/src/infrastructure-wrapper/filters/all-exceptions.filter.ts b/packages/api/src/infrastructure-wrapper/filters/all-exceptions.filter.ts
index b67e7c5fc..91ebd7e39 100644
--- a/packages/api/src/infrastructure-wrapper/filters/all-exceptions.filter.ts
+++ b/packages/api/src/infrastructure-wrapper/filters/all-exceptions.filter.ts
@@ -14,6 +14,7 @@ import {
   DomainNotImplementedException,
   DomainRuleViolationException,
   StagedChangesExistException,
+  ConflictException,
 } from '@arc/core';
 
 /**
@@ -103,6 +104,14 @@ export class AllExceptionsFilter implements ExceptionFilter {
         issues: exception.issues as Issue[],
       };
     }
+    if (exception instanceof ConflictException) {
+      return {
+        status: HttpStatus.CONFLICT,
+        errorCode: exception.errorCode,
+        details: exception.details,
+        issues: undefined,
+      };
+    }
     if (exception instanceof DomainException) {
       return {
         status:
diff --git a/packages/api/src/presentation/rest/common/dto/component-collection-with-subsystems.dto.ts b/packages/api/src/presentation/rest/common/dto/component-collection-with-subsystems.dto.ts
index 16ca99a62..4ce966474 100644
--- a/packages/api/src/presentation/rest/common/dto/component-collection-with-subsystems.dto.ts
+++ b/packages/api/src/presentation/rest/common/dto/component-collection-with-subsystems.dto.ts
@@ -5,7 +5,7 @@
 
 import {ApiProperty} from '@nestjs/swagger';
 import {ComponentsResponseDto} from './component-collection-response.dto.js';
-import {SubsystemResponseDto} from '../../modules/subsystem/dto/subsystem.dto.js';
+import {SubsystemComponentsResponseDto} from './subsystem-components-response.dto.js';
 
 /**
  * DTO containing a collection of components with subsystem hierarchy.
@@ -15,11 +15,11 @@ import {SubsystemResponseDto} from '../../modules/subsystem/dto/subsystem.dto.js
 export class ComponentsWithSubsystemsResponseDto extends ComponentsResponseDto {
   @ApiProperty({
     description: 'Hierarchical subsystem structure with nested components',
-    type: () => SubsystemResponseDto,
+    type: () => SubsystemComponentsResponseDto,
     required: false,
     isArray: true,
   })
-  subsystems?: SubsystemResponseDto[];
+  subsystems: SubsystemComponentsResponseDto[];
 
   constructor() {
     super();
diff --git a/packages/api/src/presentation/rest/common/dto/subsystem-components-response.dto.ts b/packages/api/src/presentation/rest/common/dto/subsystem-components-response.dto.ts
new file mode 100644
index 000000000..6bb5bc818
--- /dev/null
+++ b/packages/api/src/presentation/rest/common/dto/subsystem-components-response.dto.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import {createZodDto} from 'nestjs-zod';
+import {ApiProperty} from '@nestjs/swagger';
+import {SubsystemComponentsDtoSchema} from '@arc/core';
+import type {ComponentsWithSubsystemsResponseDto} from './component-collection-with-subsystems.dto.js';
+
+import {ComponentsWithSubsystemsResponseDto as ComponentsWithSubsystemsResponseDtoClass} from './component-collection-with-subsystems.dto.js';
+
+export class SubsystemComponentsResponseDto extends createZodDto(
+  SubsystemComponentsDtoSchema,
+) {
+  @ApiProperty({
+    description:
+      'Child components within this subsystem (spfModules, dataLinks, controlLinks, nested subsystems)',
+    type: () => ComponentsWithSubsystemsResponseDtoClass,
+    required: true,
+  })
+  declare children: ComponentsWithSubsystemsResponseDto;
+}
diff --git a/packages/api/src/presentation/rest/common/swagger-doc/dto-examples/usecase-api-examples.ts b/packages/api/src/presentation/rest/common/swagger-doc/dto-examples/usecase-api-examples.ts
index 2f402c6e4..4ec6b40e6 100644
--- a/packages/api/src/presentation/rest/common/swagger-doc/dto-examples/usecase-api-examples.ts
+++ b/packages/api/src/presentation/rest/common/swagger-doc/dto-examples/usecase-api-examples.ts
@@ -296,7 +296,7 @@ export const UsecaseComponentsExample = {
       totalLinksAtPort: 0,
       relatedEndPointLinks: [] as EndPointLink[],
     });
-    spfModule1.dataPorts = [inputPort1, outputPort1];
+    Object.assign(spfModule1, {dataPorts: [inputPort1, outputPort1]});
 
     const inputPort2 = Object.assign(new DataPortResponseDto(), {
       systemId: '2003',
@@ -316,7 +316,7 @@ export const UsecaseComponentsExample = {
       totalLinksAtPort: 0,
       relatedEndPointLinks: [] as EndPointLink[],
     });
-    spfModule2.dataPorts = [inputPort2, outputPort2];
+    Object.assign(spfModule2, {dataPorts: [inputPort2, outputPort2]});
 
     // Add control ports to modules
     const controlPort1 = Object.assign(new ControlPortResponseDto(), {
@@ -327,7 +327,7 @@ export const UsecaseComponentsExample = {
       intents: [],
       relatedEndPointLinks: [] as EndPointLink[],
     });
-    spfModule1.controlPorts = [controlPort1];
+    Object.assign(spfModule1, {controlPorts: [controlPort1]});
 
     const controlPort2 = Object.assign(new ControlPortResponseDto(), {
       systemId: '3002',
@@ -345,7 +345,7 @@ export const UsecaseComponentsExample = {
       intents: [],
       relatedEndPointLinks: [] as EndPointLink[],
     });
-    spfModule2.controlPorts = [controlPort2, controlPort3];
+    Object.assign(spfModule2, {controlPorts: [controlPort2, controlPort3]});
 
     componentCollection.spfModules = [
       spfModule1,
diff --git a/packages/api/src/presentation/rest/modules/data-link/data-link.controller.ts b/packages/api/src/presentation/rest/modules/data-link/data-link.controller.ts
index 35780ea61..4487bccdd 100644
--- a/packages/api/src/presentation/rest/modules/data-link/data-link.controller.ts
+++ b/packages/api/src/presentation/rest/modules/data-link/data-link.controller.ts
@@ -24,13 +24,16 @@ import {ApiResult} from '../../common/dto/api-response/api-result.dto.js';
 import {PartialSuccessInterceptor} from '../../common/interceptors/partial-success.interceptor.js';
 import {toApiResult} from '../../common/result/to-api-result.js';
 import {CreateDataLinkRequest} from './dto/request/create-data-link-request.dto.js';
+import {CreateDataLinkWithSubsystemsRequest} from './dto/request/create-data-link-with-subsystems-request.dto.js';
 import {ComponentsResponseDto} from '../../common/dto/component-collection-response.dto.js';
 import {ComponentsWithSubsystemsResponseDto} from '../../common/dto/component-collection-with-subsystems.dto.js';
 import {
   CommandBus,
   CreateDataLinkCommand,
+  CreateDataLinkWithSubsystemsCommand,
   DeleteDataLinkCommand,
   Result,
+  type ComponentCollectionWithSubsystemsDto as ComponentCollectionWithSubsystemsDtoType,
 } from '@arc/core';
 
 /**
@@ -96,12 +99,12 @@ export class DataLinkController extends BaseController {
   }
 
   /**
-   * Create a new data link (flat / collapsed view).
+   * Create a new data link (collapsed view, module endpoints only).
    * Stores all link segments in DB; returns ComponentsResponseDto.
    */
   @Post()
   @ApiDocumentationWithExample({
-    summary: 'Create a new data link (flat view)',
+    summary: 'Create a new data link',
     description:
       'Creates a data link between two modules. Stores all segments (mod→SS, SS→SS, SS→mod) in the DB. ' +
       'Returns a flat ComponentsResponseDto with the created link.',
@@ -137,11 +140,12 @@ export class DataLinkController extends BaseController {
     );
 
     const command = new CreateDataLinkCommand(
-      Number(createDto.sourceNodeSystemId),
-      Number(createDto.sourcePortSystemId),
-      Number(createDto.destinationNodeSystemId),
-      Number(createDto.destinationPortSystemId),
-      createDto.type ?? 'normal',
+      createDto.sourceModuleSystemId,
+      createDto.sourcePortSystemId,
+      createDto.destinationModuleSystemId,
+      createDto.destinationPortSystemId,
+      createDto.isInterUsecase,
+      createDto.isEc,
     );
 
     const components =
@@ -160,7 +164,7 @@ export class DataLinkController extends BaseController {
     description:
       'Creates a data link — SAME DB write as POST /data-links. ' +
       'Returns ComponentsWithSubsystemsResponseDto with the created link and subsystem structure.',
-    requestDto: CreateDataLinkRequest,
+    requestDto: CreateDataLinkWithSubsystemsRequest,
     requestDtoDescription: 'Data link creation parameters',
     responses: [
       {
@@ -182,21 +186,24 @@ export class DataLinkController extends BaseController {
   })
   async createDataLinkWithSubsystems(
     @Param('projectId') projectId: string,
-    @Body() createDto: CreateDataLinkRequest,
+    @Body() createDto: CreateDataLinkWithSubsystemsRequest,
   ): Promise<ApiResult<ComponentsWithSubsystemsResponseDto>> {
     console.log('Creating data link (with-subsystems) for project:', projectId);
 
-    const command = new CreateDataLinkCommand(
-      Number(createDto.sourceNodeSystemId),
-      Number(createDto.sourcePortSystemId),
-      Number(createDto.destinationNodeSystemId),
-      Number(createDto.destinationPortSystemId),
-      createDto.type ?? 'normal',
+    const command = new CreateDataLinkWithSubsystemsCommand(
+      createDto.sourceNodeSystemId,
+      createDto.sourcePortSystemId,
+      createDto.destinationNodeSystemId,
+      createDto.destinationPortSystemId,
+      createDto.isInterUsecase,
+      createDto.isEc,
     );
 
     const components =
-      await this.commandBus.execute<ComponentsResponseDto>(command);
-    return toApiResult(Result.ok({...components, subsystems: []}));
+      await this.commandBus.execute<ComponentCollectionWithSubsystemsDtoType>(
+        command,
+      );
+    return toApiResult(Result.ok(components));
   }
 
   /**
@@ -244,7 +251,6 @@ export class DataLinkController extends BaseController {
     const command = new DeleteDataLinkCommand(
       Number.parseInt(dataLinkSystemId, 10),
     );
-
     const deleted = await this.commandBus.execute<DataLinkResponseDto>(command);
     return toApiResult(Result.ok(deleted));
   }
diff --git a/packages/api/src/presentation/rest/modules/data-link/dto/request/create-data-link-request.dto.ts b/packages/api/src/presentation/rest/modules/data-link/dto/request/create-data-link-request.dto.ts
index 7673e0032..50394c814 100644
--- a/packages/api/src/presentation/rest/modules/data-link/dto/request/create-data-link-request.dto.ts
+++ b/packages/api/src/presentation/rest/modules/data-link/dto/request/create-data-link-request.dto.ts
@@ -3,54 +3,54 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-import {IsIn, IsNotEmpty, IsOptional, IsString} from 'class-validator';
+import {IsBoolean, IsOptional, IsString} from 'class-validator';
 import {ApiProperty} from '@nestjs/swagger';
 
-/**
- * DTO for creating a new data link
- */
 export class CreateDataLinkRequest {
   @ApiProperty({
-    description: 'Type of data link',
+    description: 'System ID of the source module node',
     type: 'string',
-    enum: ['normal', 'EC', 'interUsecase'],
-    default: 'normal',
-    required: false,
   })
   @IsString()
-  @IsIn(['normal', 'EC', 'interUsecase'])
-  @IsOptional()
-  type?: 'normal' | 'EC' | 'interUsecase' = 'normal';
+  sourceModuleSystemId!: string;
 
   @ApiProperty({
-    description: 'System ID of the source node/module',
+    description: 'System ID of the source port (must be OUTPUT)',
     type: 'string',
   })
-  @IsNotEmpty()
   @IsString()
-  sourceNodeSystemId!: string;
+  sourcePortSystemId!: string;
 
   @ApiProperty({
-    description: 'System ID of the source port',
+    description: 'System ID of the destination module node',
     type: 'string',
   })
-  @IsNotEmpty()
   @IsString()
-  sourcePortSystemId!: string;
+  destinationModuleSystemId!: string;
 
   @ApiProperty({
-    description: 'System ID of the destination node/module',
+    description: 'System ID of the destination port (must be INPUT)',
     type: 'string',
   })
-  @IsNotEmpty()
   @IsString()
-  destinationNodeSystemId!: string;
+  destinationPortSystemId!: string;
 
   @ApiProperty({
-    description: 'System ID of the destination port',
-    type: 'string',
+    description:
+      'If true, derives INTER_USECASE linkType. Server validates source and dest subgraphs are in different usecases.',
+    type: 'boolean',
+    required: false,
   })
-  @IsNotEmpty()
-  @IsString()
-  destinationPortSystemId!: string;
+  @IsBoolean()
+  @IsOptional()
+  isInterUsecase?: boolean;
+
+  @ApiProperty({
+    description: 'EC flag. Only valid when derived linkType is INTRA_USECASE.',
+    type: 'boolean',
+    required: false,
+  })
+  @IsBoolean()
+  @IsOptional()
+  isEc?: boolean;
 }
diff --git a/packages/api/src/presentation/rest/modules/data-link/dto/request/create-data-link-with-subsystems-request.dto.ts b/packages/api/src/presentation/rest/modules/data-link/dto/request/create-data-link-with-subsystems-request.dto.ts
new file mode 100644
index 000000000..0308ad3c4
--- /dev/null
+++ b/packages/api/src/presentation/rest/modules/data-link/dto/request/create-data-link-with-subsystems-request.dto.ts
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import {IsBoolean, IsOptional, IsString} from 'class-validator';
+import {ApiProperty} from '@nestjs/swagger';
+
+export class CreateDataLinkWithSubsystemsRequest {
+  @ApiProperty({
+    description: 'System ID of the source node (module or subsystem)',
+    type: 'string',
+  })
+  @IsString()
+  sourceNodeSystemId!: string;
+
+  @ApiProperty({description: 'System ID of the source port', type: 'string'})
+  @IsString()
+  sourcePortSystemId!: string;
+
+  @ApiProperty({
+    description: 'System ID of the destination node (module or subsystem)',
+    type: 'string',
+  })
+  @IsString()
+  destinationNodeSystemId!: string;
+
+  @ApiProperty({
+    description: 'System ID of the destination port',
+    type: 'string',
+  })
+  @IsString()
+  destinationPortSystemId!: string;
+
+  @ApiProperty({
+    description:
+      'If true, derives INTER_USECASE linkType. Only meaningful when both endpoints are modules.',
+    type: 'boolean',
+    required: false,
+  })
+  @IsBoolean()
+  @IsOptional()
+  isInterUsecase?: boolean;
+
+  @ApiProperty({
+    description:
+      'EC flag. Only valid when both endpoints are modules and derived linkType is INTRA_USECASE.',
+    type: 'boolean',
+    required: false,
+  })
+  @IsBoolean()
+  @IsOptional()
+  isEc?: boolean;
+}
diff --git a/packages/api/tests/e2e/data-links/create-data-link.e2e-spec.ts b/packages/api/tests/e2e/data-links/create-data-link.e2e-spec.ts
new file mode 100644
index 000000000..399acb146
--- /dev/null
+++ b/packages/api/tests/e2e/data-links/create-data-link.e2e-spec.ts
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import request from 'supertest';
+import type {INestApplication} from '@nestjs/common';
+import {setupE2ETest, teardownE2ETest} from '../helpers/e2e-test-setup.js';
+
+/**
+ * E2E tests for POST /data-links and POST /data-links/with-subsystems.
+ *
+ * Tests that require seeded modules/ports are marked with TODO — fill in actual
+ * system IDs from your test project after uploading a fixture file.
+ *
+ * The self-loop test (422) runs without seeded data because the handler checks
+ * this before any DB queries.
+ */
+describe('POST /data-links (flat mode)', () => {
+  let app: INestApplication;
+  let httpServer: unknown;
+  let authToken: string;
+
+  beforeAll(async () => {
+    const setup = await setupE2ETest();
+    app = setup.app;
+    httpServer = setup.httpServer;
+    authToken = setup.authToken;
+  }, 120_000);
+
+  afterAll(async () => {
+    await teardownE2ETest(app);
+  });
+
+  it('returns 401 when no auth token is provided', async () => {
+    const res = await request(httpServer)
+      .post('/arc-api/v1/projects/any-project/data-links')
+      .send({
+        sourceModuleSystemId: '201',
+        sourcePortSystemId: '301',
+        destinationModuleSystemId: '202',
+        destinationPortSystemId: '302',
+      });
+    expect(res.status).toBe(401);
+  });
+
+  it('returns 422 when source equals destination module (self-loop, FR-DL-06)', async () => {
+    const res = await request(httpServer)
+      .post('/arc-api/v1/projects/some-project/data-links')
+      .set('Authorization', `Bearer ${authToken}`)
+      .send({
+        sourceModuleSystemId: '201',
+        sourcePortSystemId: '301',
+        destinationModuleSystemId: '201',
+        destinationPortSystemId: '302',
+      });
+    // SessionGuard/AuthGuard may fire before handler validation depending on the project.
+    // The key check is the endpoint parses the request correctly and returns an HTTP error.
+    expect([401, 403, 422]).toContain(res.status);
+  });
+
+  // TODO: fill in real IDs after uploading a fixture file with two modules
+  // it('returns 201 and a DataLink for a valid intra-subgraph link', async () => {
+  //   const res = await request(httpServer)
+  //     .post(`/arc-api/v1/projects/${projectId}/data-links`)
+  //     .set('Authorization', `Bearer ${authToken}`)
+  //     .send({
+  //       sourceModuleSystemId: '<SOURCE_MODULE_ID>',
+  //       sourcePortSystemId: '<SOURCE_OUTPUT_PORT_ID>',
+  //       destinationModuleSystemId: '<DEST_MODULE_ID>',
+  //       destinationPortSystemId: '<DEST_INPUT_PORT_ID>',
+  //     });
+  //   expect(res.status).toBe(201);
+  //   expect(res.body.data.dataLinks).toHaveLength(1);
+  // });
+});
+
+describe('POST /data-links/with-subsystems', () => {
+  let app: INestApplication;
+  let httpServer: unknown;
+  let authToken: string;
+
+  beforeAll(async () => {
+    const setup = await setupE2ETest();
+    app = setup.app;
+    httpServer = setup.httpServer;
+    authToken = setup.authToken;
+  }, 120_000);
+
+  afterAll(async () => {
+    await teardownE2ETest(app);
+  });
+
+  it('returns 401 when no auth token is provided', async () => {
+    const res = await request(httpServer)
+      .post('/arc-api/v1/projects/any-project/data-links/with-subsystems')
+      .send({
+        sourceNodeSystemId: '501',
+        sourcePortSystemId: '401',
+        destinationNodeSystemId: '202',
+        destinationPortSystemId: '302',
+      });
+    expect(res.status).toBe(401);
+  });
+
+  it('returns 422 when source equals destination node (self-loop, FR-DLS-04)', async () => {
+    const res = await request(httpServer)
+      .post('/arc-api/v1/projects/some-project/data-links/with-subsystems')
+      .set('Authorization', `Bearer ${authToken}`)
+      .send({
+        sourceNodeSystemId: '201',
+        sourcePortSystemId: '301',
+        destinationNodeSystemId: '201',
+        destinationPortSystemId: '302',
+      });
+    expect([401, 403, 422]).toContain(res.status);
+  });
+
+  // TODO: fill in real IDs after uploading a fixture file with subsystem nodes
+  // it('returns 201 with SLS and no DataLink when one endpoint is a subsystem (FR-DLS-11)', ...);
+});
diff --git a/packages/core/src/application/file-operations/upload-file/services/entity-builders/subsystem-builder.ts b/packages/core/src/application/file-operations/upload-file/services/entity-builders/subsystem-builder.ts
index e88a21057..9f63ee28b 100644
--- a/packages/core/src/application/file-operations/upload-file/services/entity-builders/subsystem-builder.ts
+++ b/packages/core/src/application/file-operations/upload-file/services/entity-builders/subsystem-builder.ts
@@ -9,8 +9,10 @@ import {SubsystemDataLink} from '../../../../../domain/entities/usecase-data/lin
 import {SubsystemControlLink} from '../../../../../domain/entities/usecase-data/links/subsystem-control-link.js';
 import {DataPort} from '../../../../../domain/entities/usecase-data/node/entities/data-port.js';
 import {ControlPort} from '../../../../../domain/entities/usecase-data/node/entities/control-port.js';
-import {SubsystemBoundaryPathService} from '../../../../../domain/services/subsystem-data-links/subsystem-boundary-path.service.js';
-import type {PathOutput} from '../../../../../domain/services/subsystem-data-links/subsystem-boundary-path.service.js';
+import {
+  SubsystemDataLinkDerivationService,
+  type SegmentDescriptor,
+} from '../../../../../domain/services/subsystem-data-links/subsystem-data-link-derivation.service.js';
 import type {UiSubsystem} from '../../../shared/awsp-serializers/v1/ui-metadata/index.js';
 import type {ForeignKeyMapper} from '../foreign-key-mapper.js';
 import type {Logger} from '../../../../../shared/types/logger.interface.js';
@@ -38,8 +40,7 @@ export interface SubsystemPathComputeInput {
 export interface SubsystemPathComputeOutput {
   paths: Array<{
     linkSystemId: number;
-    nodeSequence: number[];
-    requiredPortType: [number, string][];
+    segments: SegmentDescriptor[];
   } | null>;
 }
 
@@ -121,20 +122,13 @@ export class SubsystemBuilder {
       input.nodeParentMapEntries,
     );
     const paths = input.links.map(link => {
-      const result = SubsystemBoundaryPathService.compute({
+      const segments = SubsystemDataLinkDerivationService.compute({
         sourceNodeSystemId: link.nodeANaturalId,
         destinationNodeSystemId: link.nodeBNaturalId,
         nodeParentMap,
       });
-      if (result.nodeSequence.length <= 2) return null;
-      return {
-        linkSystemId: link.systemId,
-        nodeSequence: result.nodeSequence,
-        requiredPortType: [...result.requiredPortType.entries()] as [
-          number,
-          string,
-        ][],
-      };
+      if (segments.length === 0) return null;
+      return {linkSystemId: link.systemId, segments};
     });
     return {paths};
   }
@@ -203,7 +197,6 @@ export class SubsystemBuilder {
   ): Promise<Subsystem[]> {
     const nodeParentMap = this.buildNodeParentMap(subsystems);
 
-    // Step A: compute paths (parallel when pool available, sequential otherwise)
     const [dataLinkPaths, controlLinkPaths] = this.shouldUseParallel(
       dataLinks,
       controlLinks,
@@ -306,7 +299,7 @@ export class SubsystemBuilder {
     dataLinks: DataLink[],
     controlLinks: ControlLink[],
     nodeParentMap: Map<number, number | null>,
-  ): Promise<[(PathOutput | null)[], (PathOutput | null)[]]> {
+  ): Promise<[(SegmentDescriptor[] | null)[], (SegmentDescriptor[] | null)[]]> {
     const nodeParentMapEntries = [
       ...nodeParentMap.entries(),
     ] as SubsystemPathComputeInput['nodeParentMapEntries'];
@@ -350,7 +343,7 @@ export class SubsystemBuilder {
       SubsystemPathComputeOutput
     >(allTasks);
 
-    // Reconstitute PathOutput from serialized worker output.
+    // Reconstitute descriptor arrays from serialized worker output.
     // dataLinkTasks.length is used to split the results array so that adding
     // further tasks before/after the control chunk would require updating this
     // split — keep dataLinkTasks and controlLinkTask adjacent in allTasks.
@@ -361,27 +354,22 @@ export class SubsystemBuilder {
 
     const dataLinkPaths = dataChunkResults.flatMap(r =>
       (r.data as SubsystemPathComputeOutput).paths.map(p =>
-        this.deserializePathOutput(p),
+        this.deserializeSegments(p),
       ),
     );
 
     const controlLinkPaths = (
       controlResult.data as SubsystemPathComputeOutput
-    ).paths.map(p => this.deserializePathOutput(p));
+    ).paths.map(p => this.deserializeSegments(p));
 
     return [dataLinkPaths, controlLinkPaths];
   }
 
-  private deserializePathOutput(
+  private deserializeSegments(
     raw: SubsystemPathComputeOutput['paths'][number],
-  ): PathOutput | null {
+  ): SegmentDescriptor[] | null {
     if (!raw) return null;
-    return {
-      nodeSequence: raw.nodeSequence,
-      requiredPortType: new Map(
-        raw.requiredPortType as [number, 'OUTPUT_INPUT' | 'INPUT_OUTPUT'][],
-      ),
-    };
+    return raw.segments;
   }
 
   // ─── Step A: sequential ───────────────────────────────────────────────────
@@ -389,62 +377,75 @@ export class SubsystemBuilder {
   private computeDataLinkPathsSequential(
     dataLinks: DataLink[],
     nodeParentMap: Map<number, number | null>,
-  ): (PathOutput | null)[] {
+  ): (SegmentDescriptor[] | null)[] {
     return dataLinks.map(link => {
-      const result = SubsystemBoundaryPathService.compute({
+      const segs = SubsystemDataLinkDerivationService.compute({
         sourceNodeSystemId: link.sourceNodeSystemId,
         destinationNodeSystemId: link.destinationNodeSystemId,
         nodeParentMap,
       });
-      return result.nodeSequence.length > 2 ? result : null;
+      return segs.length > 0 ? segs : null;
     });
   }
 
   private computeControlLinkPathsSequential(
     controlLinks: ControlLink[],
     nodeParentMap: Map<number, number | null>,
-  ): (PathOutput | null)[] {
+  ): (SegmentDescriptor[] | null)[] {
     return controlLinks.map(link => {
-      const result = SubsystemBoundaryPathService.compute({
+      const segs = SubsystemDataLinkDerivationService.compute({
         sourceNodeSystemId: link.peerNodeASystemId,
         destinationNodeSystemId: link.peerNodeBSystemId,
         nodeParentMap,
       });
-      return result.nodeSequence.length > 2 ? result : null;
+      return segs.length > 0 ? segs : null;
     });
   }
 
   // ─── Step B ───────────────────────────────────────────────────────────────
 
   private collectDataPortRequirements(
-    paths: (PathOutput | null)[],
+    paths: (SegmentDescriptor[] | null)[],
   ): Map<DataPortKey, {portIoType: string}> {
     const reqs = new Map<DataPortKey, {portIoType: string}>();
-    for (const [i, path] of paths.entries()) {
-      if (!path) continue;
-      const {nodeSequence, requiredPortType} = path;
-      for (let j = 1; j < nodeSequence.length - 1; j++) {
-        const subsystemNaturalId = nodeSequence[j];
-        const key: DataPortKey = `d:${i}:${subsystemNaturalId}`;
-        const ioType =
-          requiredPortType.get(subsystemNaturalId) ?? 'OUTPUT_INPUT';
-        reqs.set(key, {portIoType: ioType});
+    for (const [i, segments] of paths.entries()) {
+      if (!segments) continue;
+      for (const segment of segments) {
+        this.applyDataPortSegment(reqs, i, segment);
       }
     }
     return reqs;
   }
 
+  private applyDataPortSegment(
+    reqs: Map<DataPortKey, {portIoType: string}>,
+    linkIndex: number,
+    seg: SegmentDescriptor,
+  ): void {
+    if (seg.sourceBoundaryPortType !== null) {
+      const key: DataPortKey = `d:${linkIndex}:${seg.sourceNodeSystemId}`;
+      if (!reqs.has(key))
+        reqs.set(key, {portIoType: seg.sourceBoundaryPortType});
+    }
+    if (seg.destBoundaryPortType !== null) {
+      const key: DataPortKey = `d:${linkIndex}:${seg.destinationNodeSystemId}`;
+      if (!reqs.has(key)) reqs.set(key, {portIoType: seg.destBoundaryPortType});
+    }
+  }
+
   private collectControlPortRequirements(
-    paths: (PathOutput | null)[],
+    paths: (SegmentDescriptor[] | null)[],
   ): Map<ControlPortKey, object> {
     const reqs = new Map<ControlPortKey, object>();
-    for (const [i, path] of paths.entries()) {
-      if (!path) continue;
-      const {nodeSequence} = path;
-      for (let j = 1; j < nodeSequence.length - 1; j++) {
-        const subsystemNaturalId = nodeSequence[j];
-        const key: ControlPortKey = `c:${i}:${subsystemNaturalId}`;
-        reqs.set(key, {});
+    for (const [i, segments] of paths.entries()) {
+      if (!segments) continue;
+      for (const segment of segments) {
+        if (segment.sourceBoundaryPortType !== null) {
+          reqs.set(`c:${i}:${segment.sourceNodeSystemId}`, {});
+        }
+        if (segment.destBoundaryPortType !== null) {
+          reqs.set(`c:${i}:${segment.destinationNodeSystemId}`, {});
+        }
       }
     }
     return reqs;
@@ -494,36 +495,33 @@ export class SubsystemBuilder {
 
   private async attachDataLinkSegments(
     dataLinks: DataLink[],
-    paths: (PathOutput | null)[],
+    paths: (SegmentDescriptor[] | null)[],
     assignments: Map<DataPortKey, DataPortAssignment>,
     fileSystemId: number,
   ): Promise<void> {
-    for (const [i, path] of paths.entries()) {
-      if (!path) continue;
+    for (const [i, segs] of paths.entries()) {
+      if (!segs) continue;
       const dataLink = dataLinks[i];
-      const {nodeSequence} = path;
-
-      for (let j = 0; j < nodeSequence.length - 1; j++) {
-        const srcNodeId = nodeSequence[j];
-        const dstNodeId = nodeSequence[j + 1];
 
+      for (const seg of segs) {
         const srcPortSystemId =
-          j === 0
+          seg.sourceBoundaryPortType === null
             ? dataLink.sourcePortSystemId
-            : assignments.get(`d:${i}:${srcNodeId}`)!.systemId;
+            : assignments.get(`d:${i}:${seg.sourceNodeSystemId}`)!.systemId;
 
         const dstPortSystemId =
-          j === nodeSequence.length - 2
+          seg.destBoundaryPortType === null
             ? dataLink.destinationPortSystemId
-            : assignments.get(`d:${i}:${dstNodeId}`)!.systemId;
+            : assignments.get(`d:${i}:${seg.destinationNodeSystemId}`)!
+                .systemId;
 
         const segmentSystemId = await this.idGenerator.getNextId(fileSystemId);
 
         dataLink.addSubsystemDataLink(
           new SubsystemDataLink({
             systemId: segmentSystemId,
-            sourceNodeSystemId: srcNodeId,
-            destinationNodeSystemId: dstNodeId,
+            sourceNodeSystemId: seg.sourceNodeSystemId,
+            destinationNodeSystemId: seg.destinationNodeSystemId,
             sourcePortSystemId: srcPortSystemId,
             destinationPortSystemId: dstPortSystemId,
             dataLinkSystemId: dataLink.systemId,
@@ -538,36 +536,33 @@ export class SubsystemBuilder {
 
   private async attachControlLinkSegments(
     controlLinks: ControlLink[],
-    paths: (PathOutput | null)[],
+    paths: (SegmentDescriptor[] | null)[],
     assignments: Map<ControlPortKey, ControlPortAssignment>,
     fileSystemId: number,
   ): Promise<void> {
-    for (const [i, path] of paths.entries()) {
-      if (!path) continue;
+    for (const [i, segs] of paths.entries()) {
+      if (!segs) continue;
       const controlLink = controlLinks[i];
-      const {nodeSequence} = path;
-
-      for (let j = 0; j < nodeSequence.length - 1; j++) {
-        const nodeANaturalId = nodeSequence[j];
-        const nodeBNaturalId = nodeSequence[j + 1];
 
+      for (const seg of segs) {
         const nodeAPortSystemId =
-          j === 0
+          seg.sourceBoundaryPortType === null
             ? controlLink.nodeAPortSystemId
-            : assignments.get(`c:${i}:${nodeANaturalId}`)!.systemId;
+            : assignments.get(`c:${i}:${seg.sourceNodeSystemId}`)!.systemId;
 
         const nodeBPortSystemId =
-          j === nodeSequence.length - 2
+          seg.destBoundaryPortType === null
             ? controlLink.nodeBPortSystemId
-            : assignments.get(`c:${i}:${nodeBNaturalId}`)!.systemId;
+            : assignments.get(`c:${i}:${seg.destinationNodeSystemId}`)!
+                .systemId;
 
         const segmentSystemId = await this.idGenerator.getNextId(fileSystemId);
 
         controlLink.subsystemControlLinks.push(
           new SubsystemControlLink(
             segmentSystemId,
-            nodeANaturalId,
-            nodeBNaturalId,
+            seg.sourceNodeSystemId,
+            seg.destinationNodeSystemId,
             nodeAPortSystemId,
             nodeBPortSystemId,
             controlLink.systemId,
diff --git a/packages/core/src/application/orchestration/cqrs/registries/command-handler-registry.ts b/packages/core/src/application/orchestration/cqrs/registries/command-handler-registry.ts
index b7a094ef2..8777b7dc5 100644
--- a/packages/core/src/application/orchestration/cqrs/registries/command-handler-registry.ts
+++ b/packages/core/src/application/orchestration/cqrs/registries/command-handler-registry.ts
@@ -93,6 +93,8 @@ import {UpdateContainerPropertyCommand} from '../../../usecase-designer/containe
 import {UpdateContainerPropertyHandler} from '../../../usecase-designer/container/update-property/update-container-property.handler.js';
 import {CreateDataLinkCommand} from '../../../usecase-designer/data-links/create/create-data-link.command.js';
 import {CreateDataLinkHandler} from '../../../usecase-designer/data-links/create/create-data-link.handler.js';
+import {CreateDataLinkWithSubsystemsCommand} from '../../../usecase-designer/data-links/create/create-data-link-with-subsystems.command.js';
+import {CreateDataLinkWithSubsystemsHandler} from '../../../usecase-designer/data-links/create/create-data-link-with-subsystems.handler.js';
 import {DeleteDataLinkCommand} from '../../../usecase-designer/data-links/delete/delete-data-link.command.js';
 import {DeleteDataLinkHandler} from '../../../usecase-designer/data-links/delete/delete-data-link.handler.js';
 import {CreateControlLinkCommand} from '../../../usecase-designer/control-links/create/create-control-link.command.js';
@@ -191,6 +193,11 @@ export class CommandHandlerRegistry {
       create: deps => new CreateDataLinkHandler(deps.uow, deps.idGeneration),
     });
 
+    this.commandHandlerFactories.set(CreateDataLinkWithSubsystemsCommand, {
+      create: deps =>
+        new CreateDataLinkWithSubsystemsHandler(deps.uow, deps.idGeneration),
+    });
+
     this.commandHandlerFactories.set(CreateControlLinkCommand, {
       create: deps => new CreateControlLinkHandler(deps.uow, deps.idGeneration),
     });
diff --git a/packages/core/src/application/ports/persistence/query-services/subsystem/subsystem-query-service.ts b/packages/core/src/application/ports/persistence/query-services/subsystem/subsystem-query-service.ts
index 40495d4ed..c0392be80 100644
--- a/packages/core/src/application/ports/persistence/query-services/subsystem/subsystem-query-service.ts
+++ b/packages/core/src/application/ports/persistence/query-services/subsystem/subsystem-query-service.ts
@@ -6,7 +6,7 @@
 import type {Result} from '../../../../shared/result/result.js';
 import type {SubsystemReadModel} from './subsystem-read-model.js';
 import type {ControlLinkReadModel} from '../link/control-link-read-model.js';
-import type {DataLinkReadModel} from '../link/data-link-read-model.js';
+import type {SubsystemDataLinkReadModel} from '../usecase/query-models/subsystem-data-link-read-model.js';
 
 export interface SubsystemQueryService {
   /**
@@ -42,5 +42,5 @@ export interface SubsystemQueryService {
   findDataLinkSegmentsByUsecaseIds(
     usecaseSystemIds: number[],
     fileSystemId: number,
-  ): Promise<Result<DataLinkReadModel[]>>;
+  ): Promise<Result<SubsystemDataLinkReadModel[]>>;
 }
diff --git a/packages/core/src/application/ports/persistence/query-services/usecase/query-models/subsystem-data-link-read-model.ts b/packages/core/src/application/ports/persistence/query-services/usecase/query-models/subsystem-data-link-read-model.ts
new file mode 100644
index 000000000..8f04feee8
--- /dev/null
+++ b/packages/core/src/application/ports/persistence/query-services/usecase/query-models/subsystem-data-link-read-model.ts
@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+export interface SubsystemDataLinkReadModel {
+  readonly systemId: number;
+  readonly sourceNodeSystemId: number;
+  readonly destinationNodeSystemId: number;
+  readonly sourcePortSystemId: number;
+  readonly destinationPortSystemId: number;
+  readonly dataLinkSystemId: number | null;
+}
diff --git a/packages/core/src/application/ports/persistence/query-services/usecase/query-models/usecase-components-with-subsystems-read-model.ts b/packages/core/src/application/ports/persistence/query-services/usecase/query-models/usecase-components-with-subsystems-read-model.ts
new file mode 100644
index 000000000..3d5169600
--- /dev/null
+++ b/packages/core/src/application/ports/persistence/query-services/usecase/query-models/usecase-components-with-subsystems-read-model.ts
@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import type {SubsystemDataLinkReadModel} from './subsystem-data-link-read-model.js';
+import type {DataPortReadModel} from '../../node/data-port-read-model.js';
+
+export class UseCaseComponentsWithSubsystemsReadModel {
+  constructor(
+    public readonly subsystemDataLinks: SubsystemDataLinkReadModel[],
+    public readonly autoCreatedDataPorts: DataPortReadModel[],
+  ) {}
+}
diff --git a/packages/core/src/application/ports/persistence/repositories/data-link/data-link.repository.ts b/packages/core/src/application/ports/persistence/repositories/data-link/data-link.repository.ts
index 7ba3ef61d..159ed090e 100644
--- a/packages/core/src/application/ports/persistence/repositories/data-link/data-link.repository.ts
+++ b/packages/core/src/application/ports/persistence/repositories/data-link/data-link.repository.ts
@@ -5,6 +5,7 @@
 
 import type {DataLink} from '../../../../../domain/entities/usecase-data/links/data-link.js';
 import type {SubsystemDataLink} from '../../../../../domain/entities/usecase-data/links/subsystem-data-link.js';
+import type {PortIoType} from '../../../../../domain/entities/common/enums/port-io-type.js';
 import type {NodeType} from '../../../../../domain/entities/usecase-data/node/node.js';
 import type {EditOptions} from '../../edit-options.js';
 import type {LinksForPair, SubgraphPair} from '../shared/links-for-pair.js';
@@ -15,6 +16,15 @@ export interface SubsystemDataRouteContext {
   nodeTypeBySystemId: ReadonlyMap<number, NodeType>;
 }
 
+export interface BoundaryPortPayload {
+  portSystemId: number;
+  nodeSystemId: number;
+  nodeParentId: number | null;
+  portIoType: PortIoType;
+  dataPortId: number;
+  fileSystemId: number;
+}
+
 export interface DataLinkRepository {
   findLinksConnectedToModule(
     moduleSystemId: number,
@@ -106,4 +116,51 @@ export interface DataLinkRepository {
    * deletedDataLinks).
    */
   findChangedInSession(fileSystemId: number): Promise<SessionChanged<DataLink>>;
+
+  /**
+   * Writes CREATE edit_action rows for the DataLink, all its SubsystemDataLinks,
+   * and all auto-created boundary DataPorts. FK order: Node(s) → DataPort(s) →
+   * DataLink → SubsystemDataLink(s). All rows share the groupId from WriteContext.
+   */
+  createDataLink(
+    dataLink: DataLink,
+    boundaryPortPayloads: BoundaryPortPayload[],
+    options?: EditOptions,
+  ): Promise<void>;
+
+  /**
+   * Looks up a DataLink by (sourcePortSystemId, destinationPortSystemId) in the
+   * session overlay (base data_links table + active edit_actions).
+   *
+   * Returns null if not found. Returns { systemId, isDeleted: true } if soft-deleted.
+   */
+  findByPortPair(
+    sourcePortSystemId: number,
+    destPortSystemId: number,
+    fileSystemId: number,
+  ): Promise<{
+    systemId: number;
+    isDeleted: boolean;
+    payload: Record<string, unknown>;
+  } | null>;
+
+  /**
+   * Re-activates a soft-deleted DataLink (FR-DL-07a).
+   * Supersedes the existing DELETE edit_action row, then inserts a new CREATE row.
+   */
+  reactivateDataLink(
+    systemId: number,
+    aggregateId: number,
+    payload: Record<string, unknown>,
+    options?: EditOptions,
+  ): Promise<void>;
+
+  /**
+   * Writes a single unresolved SLS (dataLinkSystemId = null) CREATE row to
+   * edit_actions. Used for FR-DLS-11 Branch B where no parent DataLink exists.
+   */
+  createSubsystemDataLink(
+    sls: SubsystemDataLink,
+    options?: EditOptions,
+  ): Promise<void>;
 }
diff --git a/packages/core/src/application/ports/persistence/repositories/module/module.repository.ts b/packages/core/src/application/ports/persistence/repositories/module/module.repository.ts
index 185f3b6e5..aba957597 100644
--- a/packages/core/src/application/ports/persistence/repositories/module/module.repository.ts
+++ b/packages/core/src/application/ports/persistence/repositories/module/module.repository.ts
@@ -11,6 +11,7 @@ import type {
 import type {DataPort} from '../../../../../domain/entities/usecase-data/node/entities/data-port.js';
 import type {ControlPort} from '../../../../../domain/entities/usecase-data/node/entities/control-port.js';
 import type {KvData} from '../../../../../domain/entities/common/entities/kv-data.js';
+import type {PortIoType} from '../../../../../domain/entities/common/enums/port-io-type.js';
 
 export type {SpfModuleBase} from '../../../../../domain/entities/usecase-data/module/spf-module.js';
 
@@ -67,6 +68,20 @@ export interface ModuleRepository {
     fileSystemId: number,
   ): Promise<SpfModule | null>;
 
+  /**
+   * Lightweight read for link-creation validation. Returns subgraphSystemId
+   * and the flat data-port list (systemId + portIoType), session overlay applied.
+   * Returns null when the node does not exist OR is not a module-type node —
+   * a subsystem ID passed in error also returns null.
+   */
+  findModulePortsForLink(
+    moduleSystemId: number,
+    fileSystemId: number,
+  ): Promise<{
+    subgraphSystemId: number;
+    ports: {systemId: number; portIoType: PortIoType}[];
+  } | null>;
+
   renameModule(
     moduleSystemId: number,
     alias: string,
diff --git a/packages/core/src/application/ports/persistence/repositories/subgraph/subgraph.repository.ts b/packages/core/src/application/ports/persistence/repositories/subgraph/subgraph.repository.ts
index 9d0dea05d..3c52fb7f7 100644
--- a/packages/core/src/application/ports/persistence/repositories/subgraph/subgraph.repository.ts
+++ b/packages/core/src/application/ports/persistence/repositories/subgraph/subgraph.repository.ts
@@ -29,6 +29,16 @@ export interface SubgraphRepository {
     options?: EditOptions,
   ): Promise<void>;
 
+  /**
+   * Returns the usecaseSystemId that owns the given subgraph (via
+   * use_case_subgraphs). Returns null if not found.
+   * Used to validate INTER_USECASE links (FR-DL-09).
+   */
+  getUsecaseSystemIdForSubgraph(
+    subgraphSystemId: number,
+    fileSystemId: number,
+  ): Promise<number | null>;
+
   /**
    * Stages CREATE rows for the Subgraph aggregate root and all its
    * SubgraphPropertyData children.
diff --git a/packages/core/src/application/ports/persistence/repositories/subsystem/subsystem.repository.ts b/packages/core/src/application/ports/persistence/repositories/subsystem/subsystem.repository.ts
index a6977f76b..22ff20b60 100644
--- a/packages/core/src/application/ports/persistence/repositories/subsystem/subsystem.repository.ts
+++ b/packages/core/src/application/ports/persistence/repositories/subsystem/subsystem.repository.ts
@@ -3,6 +3,8 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
+import type {PortIoType} from '../../../../../domain/entities/common/enums/port-io-type.js';
+
 import type {EditOptions} from '../../edit-options.js';
 
 /** Identifies a subsystem control port without losing its aggregate owner. */
@@ -20,4 +22,46 @@ export interface SubsystemRepository {
     fileSystemId: number,
     options?: EditOptions,
   ): Promise<void>;
+
+  /**
+   * Returns a map of all node systemIds → parentId (null if top-level) for
+   * the given file. Covers both subsystem and module nodes.
+   */
+  getAllNodesWithParents(
+    fileSystemId: number,
+  ): Promise<Map<number, number | null>>;
+
+  /**
+   * Returns the portIoType of the DataPort with the given systemId, applying
+   * the session overlay. Returns null if not found.
+   */
+  getPortIoType(
+    portSystemId: number,
+    fileSystemId: number,
+  ): Promise<PortIoType | null>;
+
+  /**
+   * Returns true if portSystemId is the source port of any non-deleted SLS
+   * in the session (base table only — overlay awareness deferred).
+   */
+  isPortOccupiedAsSource(
+    portSystemId: number,
+    fileSystemId: number,
+  ): Promise<boolean>;
+
+  /**
+   * Returns true if portSystemId is the dest port of any non-deleted SLS
+   * in the session (base table only — overlay awareness deferred).
+   */
+  isPortOccupiedAsDest(
+    portSystemId: number,
+    fileSystemId: number,
+  ): Promise<boolean>;
+
+  /**
+   * Returns true if a DataPort with the given systemId exists in the file
+   * (session overlay + base table). Used to distinguish 404 (port missing)
+   * from 422 (port belongs to wrong module).
+   */
+  portExists(portSystemId: number, fileSystemId: number): Promise<boolean>;
 }
diff --git a/packages/core/src/application/usecase-designer/data-links/create/build-traversal-entities.ts b/packages/core/src/application/usecase-designer/data-links/create/build-traversal-entities.ts
new file mode 100644
index 000000000..5d32336bb
--- /dev/null
+++ b/packages/core/src/application/usecase-designer/data-links/create/build-traversal-entities.ts
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import type {IdGenerationPort} from '../../../ports/id-generation/id-generation.port.js';
+import type {BoundaryPortPayload} from '../../../ports/persistence/repositories/data-link/data-link.repository.js';
+import {SubsystemDataLink} from '../../../../domain/entities/usecase-data/links/subsystem-data-link.js';
+import type {SegmentDescriptor} from '../../../../domain/services/subsystem-data-links/subsystem-data-link-derivation.service.js';
+
+/**
+ * Given the segment descriptors from SubsystemDataLinkDerivationService,
+ * allocates system IDs for boundary ports and SLS segments, then returns
+ * both arrays ready for persistence via DataLinkRepository.createDataLink.
+ *
+ * nodeParentMap is required to populate BoundaryPortPayload.nodeParentId
+ * (used by the TypeORM repository when writing boundary port Node rows).
+ * SegmentDescriptor does not carry nodeParentId itself, so the caller must
+ * pass the same map it already loaded for the derivation service call.
+ */
+export async function buildTraversalEntities(
+  segments: SegmentDescriptor[],
+  srcPortId: number,
+  dstPortId: number,
+  dataLinkSystemId: number,
+  fileSystemId: number,
+  idGeneration: IdGenerationPort,
+  nodeParentMap: Map<number, number | null>,
+): Promise<{
+  boundaryPortPayloads: BoundaryPortPayload[];
+  slsSegments: SubsystemDataLink[];
+}> {
+  const boundaryPortPayloads: BoundaryPortPayload[] = [];
+  const slsSegments: SubsystemDataLink[] = [];
+
+  if (segments.length === 0) {
+    return {boundaryPortPayloads, slsSegments};
+  }
+
+  // Allocate one port per subsystem boundary node. A node may appear as both
+  // dest of one segment and source of the next — deduplicate by checking portMap.
+  const portMap = new Map<number, number>();
+
+  for (const seg of segments) {
+    if (
+      seg.sourceBoundaryPortType !== null &&
+      !portMap.has(seg.sourceNodeSystemId)
+    ) {
+      const portSystemId = await idGeneration.getNextId(fileSystemId);
+      portMap.set(seg.sourceNodeSystemId, portSystemId);
+      boundaryPortPayloads.push({
+        portSystemId,
+        nodeSystemId: seg.sourceNodeSystemId,
+        nodeParentId: nodeParentMap.get(seg.sourceNodeSystemId) ?? null,
+        portIoType: seg.sourceBoundaryPortType,
+        dataPortId: portSystemId,
+        fileSystemId,
+      });
+    }
+    if (
+      seg.destBoundaryPortType !== null &&
+      !portMap.has(seg.destinationNodeSystemId)
+    ) {
+      const portSystemId = await idGeneration.getNextId(fileSystemId);
+      portMap.set(seg.destinationNodeSystemId, portSystemId);
+      boundaryPortPayloads.push({
+        portSystemId,
+        nodeSystemId: seg.destinationNodeSystemId,
+        nodeParentId: nodeParentMap.get(seg.destinationNodeSystemId) ?? null,
+        portIoType: seg.destBoundaryPortType,
+        dataPortId: portSystemId,
+        fileSystemId,
+      });
+    }
+  }
+
+  for (const seg of segments) {
+    const segSrcPort =
+      seg.sourceBoundaryPortType === null
+        ? srcPortId
+        : portMap.get(seg.sourceNodeSystemId)!;
+    const segDstPort =
+      seg.destBoundaryPortType === null
+        ? dstPortId
+        : portMap.get(seg.destinationNodeSystemId)!;
+    const slsId = await idGeneration.getNextId(fileSystemId);
+    slsSegments.push(
+      new SubsystemDataLink({
+        systemId: slsId,
+        sourceNodeSystemId: seg.sourceNodeSystemId,
+        destinationNodeSystemId: seg.destinationNodeSystemId,
+        sourcePortSystemId: segSrcPort,
+        destinationPortSystemId: segDstPort,
+        dataLinkSystemId,
+        fileSystemId,
+      }),
+    );
+  }
+
+  return {boundaryPortPayloads, slsSegments};
+}
diff --git a/packages/core/src/application/usecase-designer/data-links/create/create-data-link-with-subsystems.command.ts b/packages/core/src/application/usecase-designer/data-links/create/create-data-link-with-subsystems.command.ts
new file mode 100644
index 000000000..7630345c3
--- /dev/null
+++ b/packages/core/src/application/usecase-designer/data-links/create/create-data-link-with-subsystems.command.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import {BaseCommand} from '../../../shared/base-command.js';
+
+export class CreateDataLinkWithSubsystemsCommand extends BaseCommand {
+  constructor(
+    public readonly sourceNodeSystemId: string,
+    public readonly sourcePortSystemId: string,
+    public readonly destinationNodeSystemId: string,
+    public readonly destinationPortSystemId: string,
+    public readonly isInterUsecase?: boolean,
+    public readonly isEc?: boolean,
+  ) {
+    super();
+  }
+}
diff --git a/packages/core/src/application/usecase-designer/data-links/create/create-data-link-with-subsystems.handler.ts b/packages/core/src/application/usecase-designer/data-links/create/create-data-link-with-subsystems.handler.ts
new file mode 100644
index 000000000..da1d1d56a
--- /dev/null
+++ b/packages/core/src/application/usecase-designer/data-links/create/create-data-link-with-subsystems.handler.ts
@@ -0,0 +1,504 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import type {CommandHandler} from '../../../orchestration/cqrs/commands/command-handler.js';
+import type {UnitOfWork} from '../../../ports/persistence/unit-of-work.js';
+import type {IdGenerationPort} from '../../../ports/id-generation/id-generation.port.js';
+import type {CreateDataLinkWithSubsystemsCommand} from './create-data-link-with-subsystems.command.js';
+import {
+  type ComponentCollectionWithSubsystemsDto,
+  type DataLinkDto,
+  mapSubsystemDataLink,
+} from '../../usecase/dto/component-collection-dto.js';
+import {DataLink} from '../../../../domain/entities/usecase-data/links/data-link.js';
+import {SubsystemDataLink} from '../../../../domain/entities/usecase-data/links/subsystem-data-link.js';
+import {LINK_TYPE} from '../../../../domain/entities/usecase-data/links/link-type.js';
+import type {LinkType} from '../../../../domain/entities/usecase-data/links/link-type.js';
+import {PORT_IO_TYPE} from '../../../../domain/entities/common/enums/port-io-type.js';
+import {SubsystemDataLinkDerivationService} from '../../../../domain/services/subsystem-data-links/subsystem-data-link-derivation.service.js';
+import {buildTraversalEntities} from './build-traversal-entities.js';
+import {
+  ConflictException,
+  DomainRuleViolationException,
+  ResourceNotFoundException,
+} from '../../../../shared/exceptions/index.js';
+import {IssueSeverity} from '../../../../shared/issues/severity.js';
+import {BinaryUtils} from '../../../../shared/utilities/binary-utils.js';
+
+function deriveLinkType(
+  isInterUsecase: boolean | undefined,
+  srcSubgraphId: number,
+  dstSubgraphId: number,
+): LinkType {
+  if (isInterUsecase === true) return LINK_TYPE.InterUsecase;
+  if (srcSubgraphId !== dstSubgraphId) return LINK_TYPE.IntraUsecase;
+  return LINK_TYPE.IntraSubgraph;
+}
+
+function emptyCollection(
+  dataLinks: DataLinkDto[] = [],
+): ComponentCollectionWithSubsystemsDto {
+  return {
+    spfModules: [],
+    dataLinks,
+    controlLinks: [],
+    subsystems: [],
+  };
+}
+
+export class CreateDataLinkWithSubsystemsHandler implements CommandHandler<
+  CreateDataLinkWithSubsystemsCommand,
+  ComponentCollectionWithSubsystemsDto
+> {
+  constructor(
+    private readonly uow: UnitOfWork,
+    private readonly idGeneration: IdGenerationPort,
+  ) {}
+
+  async handle(
+    command: CreateDataLinkWithSubsystemsCommand,
+  ): Promise<ComponentCollectionWithSubsystemsDto> {
+    const uow = this.uow;
+    await uow.startTransaction();
+    try {
+      const {session} = uow.getWriteContext();
+      const fileSystemId = session.fileSystemId;
+
+      const srcNodeId = Number.parseInt(command.sourceNodeSystemId, 10);
+      const dstNodeId = Number.parseInt(command.destinationNodeSystemId, 10);
+      const srcPortId = Number.parseInt(command.sourcePortSystemId, 10);
+      const dstPortId = Number.parseInt(command.destinationPortSystemId, 10);
+
+      // FR-DLS-04: self-loop check
+      if (srcNodeId === dstNodeId) {
+        throw new DomainRuleViolationException([
+          {
+            code: 'SELF_LOOP',
+            message: `Source and destination node must differ: ${BinaryUtils.toHexString(srcNodeId)}`,
+            severity: IssueSeverity.Error,
+          },
+        ]);
+      }
+
+      const subsystemRepo = uow.getSubsystemRepository();
+      const srcIsSubsystem = await subsystemRepo.subsystemExists(
+        srcNodeId,
+        fileSystemId,
+      );
+      const dstIsSubsystem = await subsystemRepo.subsystemExists(
+        dstNodeId,
+        fileSystemId,
+      );
+
+      if (srcIsSubsystem || dstIsSubsystem) {
+        return this.handleBranchB(
+          command,
+          srcNodeId,
+          dstNodeId,
+          srcPortId,
+          dstPortId,
+          srcIsSubsystem,
+          dstIsSubsystem,
+          fileSystemId,
+          uow,
+          subsystemRepo,
+        );
+      }
+
+      return this.handleBranchA(
+        command,
+        srcNodeId,
+        dstNodeId,
+        srcPortId,
+        dstPortId,
+        fileSystemId,
+        uow,
+        subsystemRepo,
+      );
+    } catch (error) {
+      if (uow.isInTransaction()) await uow.rollback();
+      throw error;
+    }
+  }
+
+  private async handleBranchA(
+    command: CreateDataLinkWithSubsystemsCommand,
+    srcNodeId: number,
+    dstNodeId: number,
+    srcPortId: number,
+    dstPortId: number,
+    fileSystemId: number,
+    uow: UnitOfWork,
+    subsystemRepo: ReturnType<UnitOfWork['getSubsystemRepository']>,
+  ): Promise<ComponentCollectionWithSubsystemsDto> {
+    // Branch A (FR-DLS-10): both endpoints are modules
+    const [srcModule, dstModule] = await this.findModules(
+      uow.getModuleRepository(),
+      subsystemRepo,
+      srcNodeId,
+      dstNodeId,
+      fileSystemId,
+    );
+
+    const srcPort = await this.findPort(
+      subsystemRepo,
+      srcModule.ports,
+      srcPortId,
+      fileSystemId,
+      'Source',
+    );
+    const dstPort = await this.findPort(
+      subsystemRepo,
+      dstModule.ports,
+      dstPortId,
+      fileSystemId,
+      'Destination',
+    );
+    this.validatePortDirections(srcPort, dstPort);
+
+    const dlEditRepo = uow.getDataLinkRepository();
+    const existing = await dlEditRepo.findByPortPair(
+      srcPortId,
+      dstPortId,
+      fileSystemId,
+    );
+    if (existing !== null && !existing.isDeleted) {
+      throw new ConflictException(
+        `DataLink for ports (${BinaryUtils.toHexString(srcPortId)}, ${BinaryUtils.toHexString(dstPortId)}) already exists.`,
+      );
+    }
+
+    const srcSubgraphId = srcModule.subgraphSystemId;
+    const dstSubgraphId = dstModule.subgraphSystemId;
+    const linkType = deriveLinkType(
+      command.isInterUsecase,
+      srcSubgraphId,
+      dstSubgraphId,
+    );
+
+    if (linkType === LINK_TYPE.InterUsecase) {
+      const subgraphRepo = uow.getSubgraphRepository();
+      const [srcUsecaseId, dstUsecaseId] = await Promise.all([
+        subgraphRepo.getUsecaseSystemIdForSubgraph(srcSubgraphId, fileSystemId),
+        subgraphRepo.getUsecaseSystemIdForSubgraph(dstSubgraphId, fileSystemId),
+      ]);
+      if (
+        srcUsecaseId !== null &&
+        dstUsecaseId !== null &&
+        srcUsecaseId === dstUsecaseId
+      ) {
+        throw new DomainRuleViolationException([
+          {
+            code: 'SAME_USECASE_INTER_USECASE',
+            message:
+              'isInterUsecase=true but source and destination belong to the same usecase.',
+            severity: IssueSeverity.Error,
+          },
+        ]);
+      }
+    }
+
+    if (command.isEc !== undefined && linkType !== LINK_TYPE.IntraUsecase) {
+      throw new DomainRuleViolationException([
+        {
+          code: 'INVALID_EC_FLAG',
+          message: 'isEc is only valid for INTRA_USECASE links.',
+          severity: IssueSeverity.Error,
+        },
+      ]);
+    }
+
+    const isEc =
+      linkType === LINK_TYPE.IntraUsecase ? (command.isEc ?? false) : undefined;
+    const nodeParentMap =
+      await subsystemRepo.getAllNodesWithParents(fileSystemId);
+    const segments = SubsystemDataLinkDerivationService.compute({
+      sourceNodeSystemId: srcNodeId,
+      destinationNodeSystemId: dstNodeId,
+      nodeParentMap,
+    });
+
+    if (existing !== null && existing.isDeleted) {
+      await dlEditRepo.reactivateDataLink(
+        existing.systemId,
+        existing.systemId,
+        {
+          sourceNodeSystemId: srcNodeId,
+          destinationNodeSystemId: dstNodeId,
+          sourcePortSystemId: srcPortId,
+          destinationPortSystemId: dstPortId,
+          linkType,
+          sourceSubgraphSystemId: srcSubgraphId,
+          destSubgraphSystemId: dstSubgraphId,
+          isEc: isEc ?? null,
+          fileSystemId,
+        },
+      );
+      const {boundaryPortPayloads, slsSegments} = await buildTraversalEntities(
+        segments,
+        srcPortId,
+        dstPortId,
+        existing.systemId,
+        fileSystemId,
+        this.idGeneration,
+        nodeParentMap,
+      );
+      if (slsSegments.length > 0) {
+        await dlEditRepo.createDataLink(
+          new DataLink({
+            systemId: existing.systemId,
+            sourceNodeSystemId: srcNodeId,
+            destinationNodeSystemId: dstNodeId,
+            sourcePortSystemId: srcPortId,
+            destinationPortSystemId: dstPortId,
+            linkType,
+            sourceSubgraphSystemId: srcSubgraphId,
+            destSubgraphSystemId: dstSubgraphId,
+            fileSystemId,
+            isEc,
+            subsystemDataLinks: slsSegments,
+          }),
+          boundaryPortPayloads,
+        );
+      }
+      await uow.commit();
+      return emptyCollection(slsSegments.map(sls => mapSubsystemDataLink(sls)));
+    }
+
+    const dataLinkSystemId = await this.idGeneration.getNextId(fileSystemId);
+    const {boundaryPortPayloads, slsSegments} = await buildTraversalEntities(
+      segments,
+      srcPortId,
+      dstPortId,
+      dataLinkSystemId,
+      fileSystemId,
+      this.idGeneration,
+      nodeParentMap,
+    );
+    await dlEditRepo.createDataLink(
+      new DataLink({
+        systemId: dataLinkSystemId,
+        sourceNodeSystemId: srcNodeId,
+        destinationNodeSystemId: dstNodeId,
+        sourcePortSystemId: srcPortId,
+        destinationPortSystemId: dstPortId,
+        linkType,
+        sourceSubgraphSystemId: srcSubgraphId,
+        destSubgraphSystemId: dstSubgraphId,
+        fileSystemId,
+        isEc,
+        subsystemDataLinks: slsSegments,
+      }),
+      boundaryPortPayloads,
+    );
+    await uow.commit();
+    return emptyCollection(slsSegments.map(sls => mapSubsystemDataLink(sls)));
+  }
+
+  private async findModules(
+    moduleRepo: ReturnType<UnitOfWork['getModuleRepository']>,
+    subsystemRepo: ReturnType<UnitOfWork['getSubsystemRepository']>,
+    srcNodeId: number,
+    dstNodeId: number,
+    fileSystemId: number,
+  ) {
+    const [srcModule, dstModule] = await Promise.all([
+      moduleRepo.findModulePortsForLink(srcNodeId, fileSystemId),
+      moduleRepo.findModulePortsForLink(dstNodeId, fileSystemId),
+    ]);
+    if (srcModule === null) {
+      const isSubsystem = await subsystemRepo.subsystemExists(
+        srcNodeId,
+        fileSystemId,
+      );
+      throw isSubsystem
+        ? new DomainRuleViolationException([
+            {
+              code: 'WRONG_NODE_TYPE',
+              message: `Source ${BinaryUtils.toHexString(srcNodeId)} is a subsystem, not a module.`,
+              severity: IssueSeverity.Error,
+            },
+          ])
+        : new ResourceNotFoundException(
+            `Source module ${BinaryUtils.toHexString(srcNodeId)} not found.`,
+          );
+    }
+    if (dstModule === null) {
+      const isSubsystem = await subsystemRepo.subsystemExists(
+        dstNodeId,
+        fileSystemId,
+      );
+      throw isSubsystem
+        ? new DomainRuleViolationException([
+            {
+              code: 'WRONG_NODE_TYPE',
+              message: `Destination ${BinaryUtils.toHexString(dstNodeId)} is a subsystem, not a module.`,
+              severity: IssueSeverity.Error,
+            },
+          ])
+        : new ResourceNotFoundException(
+            `Destination module ${BinaryUtils.toHexString(dstNodeId)} not found.`,
+          );
+    }
+    return [srcModule, dstModule] as const;
+  }
+
+  private async findPort(
+    subsystemRepo: ReturnType<UnitOfWork['getSubsystemRepository']>,
+    ports: {systemId: number; portIoType: string}[],
+    portId: number,
+    fileSystemId: number,
+    side: 'Source' | 'Destination',
+  ) {
+    const port = ports.find(p => p.systemId === portId);
+    if (port) return port;
+    if (!(await subsystemRepo.portExists(portId, fileSystemId))) {
+      throw new ResourceNotFoundException(
+        `${side} port ${BinaryUtils.toHexString(portId)} not found.`,
+      );
+    }
+    throw new DomainRuleViolationException([
+      {
+        code: 'PORT_OWNERSHIP_MISMATCH',
+        message: `Port ${BinaryUtils.toHexString(portId)} does not belong to ${side.toLowerCase()} module — ownership check failed.`,
+        severity: IssueSeverity.Error,
+      },
+    ]);
+  }
+
+  private validatePortDirections(
+    srcPort: {portIoType: string},
+    dstPort: {portIoType: string},
+  ): void {
+    if (srcPort.portIoType !== PORT_IO_TYPE.Output) {
+      throw new DomainRuleViolationException([
+        {
+          code: 'WRONG_PORT_DIRECTION',
+          message: `Source port must be OUTPUT, got ${srcPort.portIoType}.`,
+          severity: IssueSeverity.Error,
+        },
+      ]);
+    }
+    if (dstPort.portIoType !== PORT_IO_TYPE.Input) {
+      throw new DomainRuleViolationException([
+        {
+          code: 'WRONG_PORT_DIRECTION',
+          message: `Destination port must be INPUT, got ${dstPort.portIoType}.`,
+          severity: IssueSeverity.Error,
+        },
+      ]);
+    }
+  }
+
+  private async handleBranchB(
+    command: CreateDataLinkWithSubsystemsCommand,
+    srcNodeId: number,
+    dstNodeId: number,
+    srcPortId: number,
+    dstPortId: number,
+    srcIsSubsystem: boolean,
+    dstIsSubsystem: boolean,
+    fileSystemId: number,
+    uow: UnitOfWork,
+    subsystemRepo: ReturnType<UnitOfWork['getSubsystemRepository']>,
+  ): Promise<ComponentCollectionWithSubsystemsDto> {
+    // Branch B (FR-DLS-11): at least one endpoint is a subsystem
+    if (command.isInterUsecase !== undefined || command.isEc !== undefined) {
+      throw new DomainRuleViolationException([
+        {
+          code: 'INVALID_FLAGS_FOR_SUBSYSTEM',
+          message:
+            'isInterUsecase and isEc must not be provided when a subsystem endpoint is involved.',
+          severity: IssueSeverity.Error,
+        },
+      ]);
+    }
+
+    // FR-DLS-03 + FR-DLS-08 + FR-DLS-07: validate subsystem-side ports
+    if (srcIsSubsystem) {
+      const srcPortType = await subsystemRepo.getPortIoType(
+        srcPortId,
+        fileSystemId,
+      );
+      if (srcPortType === null) {
+        throw new ResourceNotFoundException(
+          `Source port ${BinaryUtils.toHexString(srcPortId)} not found.`,
+        );
+      }
+      if (srcPortType !== PORT_IO_TYPE.InputOutput) {
+        throw new DomainRuleViolationException([
+          {
+            code: 'WRONG_SUBSYSTEM_PORT_TYPE',
+            message: `Source subsystem port must be InputOutput, got ${srcPortType}.`,
+            severity: IssueSeverity.Error,
+          },
+        ]);
+      }
+      const occupied = await subsystemRepo.isPortOccupiedAsSource(
+        srcPortId,
+        fileSystemId,
+      );
+      if (occupied) {
+        throw new DomainRuleViolationException([
+          {
+            code: 'PORT_ALREADY_OCCUPIED',
+            message: `Source port ${BinaryUtils.toHexString(srcPortId)} is already occupied as source of an SLS.`,
+            severity: IssueSeverity.Error,
+          },
+        ]);
+      }
+    }
+    if (dstIsSubsystem) {
+      const dstPortType = await subsystemRepo.getPortIoType(
+        dstPortId,
+        fileSystemId,
+      );
+      if (dstPortType === null) {
+        throw new ResourceNotFoundException(
+          `Destination port ${BinaryUtils.toHexString(dstPortId)} not found.`,
+        );
+      }
+      if (dstPortType !== PORT_IO_TYPE.OutputInput) {
+        throw new DomainRuleViolationException([
+          {
+            code: 'WRONG_SUBSYSTEM_PORT_TYPE',
+            message: `Destination subsystem port must be OutputInput, got ${dstPortType}.`,
+            severity: IssueSeverity.Error,
+          },
+        ]);
+      }
+      const occupied = await subsystemRepo.isPortOccupiedAsDest(
+        dstPortId,
+        fileSystemId,
+      );
+      if (occupied) {
+        throw new DomainRuleViolationException([
+          {
+            code: 'PORT_ALREADY_OCCUPIED',
+            message: `Destination port ${BinaryUtils.toHexString(dstPortId)} is already occupied as destination of an SLS.`,
+            severity: IssueSeverity.Error,
+          },
+        ]);
+      }
+    }
+
+    const slsSystemId = await this.idGeneration.getNextId(fileSystemId);
+    const sls = new SubsystemDataLink({
+      systemId: slsSystemId,
+      sourceNodeSystemId: srcNodeId,
+      destinationNodeSystemId: dstNodeId,
+      sourcePortSystemId: srcPortId,
+      destinationPortSystemId: dstPortId,
+      dataLinkSystemId: null,
+      fileSystemId,
+    });
+
+    const dlEditRepo = uow.getDataLinkRepository();
+    await dlEditRepo.createSubsystemDataLink(sls);
+    await uow.commit();
+    // FR-DLS-14: return the persisted SLS in the response
+    return emptyCollection([mapSubsystemDataLink(sls)]);
+  }
+}
diff --git a/packages/core/src/application/usecase-designer/data-links/create/create-data-link.command.ts b/packages/core/src/application/usecase-designer/data-links/create/create-data-link.command.ts
index 1e501011e..7f6407bd4 100644
--- a/packages/core/src/application/usecase-designer/data-links/create/create-data-link.command.ts
+++ b/packages/core/src/application/usecase-designer/data-links/create/create-data-link.command.ts
@@ -7,11 +7,12 @@ import {BaseCommand} from '../../../shared/base-command.js';
 
 export class CreateDataLinkCommand extends BaseCommand {
   constructor(
-    public readonly sourceNodeSystemId: number,
-    public readonly sourcePortSystemId: number,
-    public readonly destinationNodeSystemId: number,
-    public readonly destinationPortSystemId: number,
-    public readonly type: 'normal' | 'EC' | 'interUsecase',
+    public readonly sourceModuleSystemId: string,
+    public readonly sourcePortSystemId: string,
+    public readonly destinationModuleSystemId: string,
+    public readonly destinationPortSystemId: string,
+    public readonly isInterUsecase?: boolean,
+    public readonly isEc?: boolean,
   ) {
     super();
   }
diff --git a/packages/core/src/application/usecase-designer/data-links/create/create-data-link.handler.ts b/packages/core/src/application/usecase-designer/data-links/create/create-data-link.handler.ts
index 01abf13b7..df647fefa 100644
--- a/packages/core/src/application/usecase-designer/data-links/create/create-data-link.handler.ts
+++ b/packages/core/src/application/usecase-designer/data-links/create/create-data-link.handler.ts
@@ -7,7 +7,23 @@ import type {CommandHandler} from '../../../orchestration/cqrs/commands/command-
 import type {UnitOfWork} from '../../../ports/persistence/unit-of-work.js';
 import type {IdGenerationPort} from '../../../ports/id-generation/id-generation.port.js';
 import type {CreateDataLinkCommand} from './create-data-link.command.js';
-import type {ComponentCollectionDto} from '../../usecase/dto/component-collection-dto.js';
+import {
+  type ComponentCollectionDto,
+  mapDataLink,
+} from '../../usecase/dto/component-collection-dto.js';
+import {DataLink} from '../../../../domain/entities/usecase-data/links/data-link.js';
+import {LINK_TYPE} from '../../../../domain/entities/usecase-data/links/link-type.js';
+import type {LinkType} from '../../../../domain/entities/usecase-data/links/link-type.js';
+import {PORT_IO_TYPE} from '../../../../domain/entities/common/enums/port-io-type.js';
+import {SubsystemDataLinkDerivationService} from '../../../../domain/services/subsystem-data-links/subsystem-data-link-derivation.service.js';
+import {buildTraversalEntities} from './build-traversal-entities.js';
+import {
+  ConflictException,
+  DomainRuleViolationException,
+  ResourceNotFoundException,
+} from '../../../../shared/exceptions/index.js';
+import {IssueSeverity} from '../../../../shared/issues/severity.js';
+import {BinaryUtils} from '../../../../shared/utilities/binary-utils.js';
 
 export class CreateDataLinkHandler implements CommandHandler<
   CreateDataLinkCommand,
@@ -18,9 +34,367 @@ export class CreateDataLinkHandler implements CommandHandler<
     private readonly idGeneration: IdGenerationPort,
   ) {}
 
-  handle(_command: CreateDataLinkCommand): Promise<ComponentCollectionDto> {
-    if (this.uow == undefined || this.idGeneration == undefined)
-      throw new Error('Input validation error');
-    throw new Error('Not implemented');
+  async handle(
+    command: CreateDataLinkCommand,
+  ): Promise<ComponentCollectionDto> {
+    const uow = this.uow;
+    await uow.startTransaction();
+    try {
+      const {session} = uow.getWriteContext();
+      const fileSystemId = session.fileSystemId;
+
+      const srcModuleId = Number.parseInt(command.sourceModuleSystemId, 10);
+      const dstModuleId = Number.parseInt(
+        command.destinationModuleSystemId,
+        10,
+      );
+      const srcPortId = Number.parseInt(command.sourcePortSystemId, 10);
+      const dstPortId = Number.parseInt(command.destinationPortSystemId, 10);
+
+      // FR-DL-06: self-loop check
+      if (srcModuleId === dstModuleId) {
+        throw new DomainRuleViolationException([
+          {
+            code: 'SELF_LOOP',
+            message: `Source and destination module must differ: ${BinaryUtils.toHexString(srcModuleId)}`,
+            severity: IssueSeverity.Error,
+          },
+        ]);
+      }
+
+      const moduleRepo = uow.getModuleRepository();
+      const subsystemRepo = uow.getSubsystemRepository();
+
+      const [srcModule, dstModule] = await this.findModules(
+        moduleRepo,
+        subsystemRepo,
+        srcModuleId,
+        dstModuleId,
+        fileSystemId,
+      );
+
+      const srcPort = await this.findPort(
+        subsystemRepo,
+        srcModule.ports,
+        srcPortId,
+        fileSystemId,
+        'Source',
+      );
+      const dstPort = await this.findPort(
+        subsystemRepo,
+        dstModule.ports,
+        dstPortId,
+        fileSystemId,
+        'Destination',
+      );
+
+      this.validatePortDirections(srcPort, srcPortId, dstPort, dstPortId);
+
+      const srcSubgraphId = srcModule.subgraphSystemId;
+      const dstSubgraphId = dstModule.subgraphSystemId;
+      const dlEditRepo = uow.getDataLinkRepository();
+
+      const existing = await dlEditRepo.findByPortPair(
+        srcPortId,
+        dstPortId,
+        fileSystemId,
+      );
+      if (existing !== null && !existing.isDeleted) {
+        throw new ConflictException(
+          `DataLink for ports (${BinaryUtils.toHexString(srcPortId)}, ${BinaryUtils.toHexString(dstPortId)}) already exists.`,
+        );
+      }
+
+      const linkType = this.deriveLinkType(
+        command.isInterUsecase,
+        srcSubgraphId,
+        dstSubgraphId,
+      );
+      if (linkType === LINK_TYPE.InterUsecase) {
+        await this.validateInterUsecase(
+          uow,
+          srcSubgraphId,
+          dstSubgraphId,
+          fileSystemId,
+        );
+      }
+
+      if (command.isEc !== undefined && linkType !== LINK_TYPE.IntraUsecase) {
+        throw new DomainRuleViolationException([
+          {
+            code: 'INVALID_EC_FLAG',
+            message: 'isEc is only valid for INTRA_USECASE links.',
+            severity: IssueSeverity.Error,
+          },
+        ]);
+      }
+
+      const isEc =
+        linkType === LINK_TYPE.IntraUsecase
+          ? (command.isEc ?? false)
+          : undefined;
+      const nodeParentMap =
+        await subsystemRepo.getAllNodesWithParents(fileSystemId);
+      const segments = SubsystemDataLinkDerivationService.compute({
+        sourceNodeSystemId: srcModuleId,
+        destinationNodeSystemId: dstModuleId,
+        nodeParentMap,
+      });
+
+      if (existing !== null && existing.isDeleted) {
+        await dlEditRepo.reactivateDataLink(
+          existing.systemId,
+          existing.systemId,
+          {
+            sourceNodeSystemId: srcModuleId,
+            destinationNodeSystemId: dstModuleId,
+            sourcePortSystemId: srcPortId,
+            destinationPortSystemId: dstPortId,
+            linkType,
+            sourceSubgraphSystemId: srcSubgraphId,
+            destSubgraphSystemId: dstSubgraphId,
+            isEc: isEc ?? null,
+            fileSystemId,
+          },
+        );
+        const {boundaryPortPayloads, slsSegments} =
+          await buildTraversalEntities(
+            segments,
+            srcPortId,
+            dstPortId,
+            existing.systemId,
+            fileSystemId,
+            this.idGeneration,
+            nodeParentMap,
+          );
+        if (slsSegments.length > 0) {
+          await dlEditRepo.createDataLink(
+            new DataLink({
+              systemId: existing.systemId,
+              sourceNodeSystemId: srcModuleId,
+              destinationNodeSystemId: dstModuleId,
+              sourcePortSystemId: srcPortId,
+              destinationPortSystemId: dstPortId,
+              linkType,
+              sourceSubgraphSystemId: srcSubgraphId,
+              destSubgraphSystemId: dstSubgraphId,
+              fileSystemId,
+              isEc,
+              subsystemDataLinks: slsSegments,
+            }),
+            boundaryPortPayloads,
+          );
+        }
+        await uow.commit();
+        return this.buildDto(
+          existing.systemId,
+          srcModuleId,
+          dstModuleId,
+          srcPortId,
+          dstPortId,
+          linkType,
+          isEc,
+        );
+      }
+
+      const dataLinkSystemId = await this.idGeneration.getNextId(fileSystemId);
+      const {boundaryPortPayloads, slsSegments} = await buildTraversalEntities(
+        segments,
+        srcPortId,
+        dstPortId,
+        dataLinkSystemId,
+        fileSystemId,
+        this.idGeneration,
+        nodeParentMap,
+      );
+      const dataLink = new DataLink({
+        systemId: dataLinkSystemId,
+        sourceNodeSystemId: srcModuleId,
+        destinationNodeSystemId: dstModuleId,
+        sourcePortSystemId: srcPortId,
+        destinationPortSystemId: dstPortId,
+        linkType,
+        sourceSubgraphSystemId: srcSubgraphId,
+        destSubgraphSystemId: dstSubgraphId,
+        fileSystemId,
+        isEc,
+        subsystemDataLinks: slsSegments,
+      });
+      await dlEditRepo.createDataLink(dataLink, boundaryPortPayloads);
+      await uow.commit();
+
+      return this.buildDto(
+        dataLink.systemId,
+        dataLink.sourceNodeSystemId,
+        dataLink.destinationNodeSystemId,
+        dataLink.sourcePortSystemId,
+        dataLink.destinationPortSystemId,
+        dataLink.linkType,
+        dataLink.isEc,
+      );
+    } catch (error) {
+      if (uow.isInTransaction()) await uow.rollback();
+      throw error;
+    }
+  }
+
+  private async findModules(
+    moduleRepo: ReturnType<UnitOfWork['getModuleRepository']>,
+    subsystemRepo: ReturnType<UnitOfWork['getSubsystemRepository']>,
+    srcModuleId: number,
+    dstModuleId: number,
+    fileSystemId: number,
+  ) {
+    const [srcModule, dstModule] = await Promise.all([
+      moduleRepo.findModulePortsForLink(srcModuleId, fileSystemId),
+      moduleRepo.findModulePortsForLink(dstModuleId, fileSystemId),
+    ]);
+    if (srcModule === null) {
+      const isSubsystem = await subsystemRepo.subsystemExists(
+        srcModuleId,
+        fileSystemId,
+      );
+      throw isSubsystem
+        ? new DomainRuleViolationException([
+            {
+              code: 'WRONG_NODE_TYPE',
+              message: `Source node ${BinaryUtils.toHexString(srcModuleId)} is a subsystem, not a module.`,
+              severity: IssueSeverity.Error,
+            },
+          ])
+        : new ResourceNotFoundException(
+            `Source module ${BinaryUtils.toHexString(srcModuleId)} not found.`,
+          );
+    }
+    if (dstModule === null) {
+      const isSubsystem = await subsystemRepo.subsystemExists(
+        dstModuleId,
+        fileSystemId,
+      );
+      throw isSubsystem
+        ? new DomainRuleViolationException([
+            {
+              code: 'WRONG_NODE_TYPE',
+              message: `Destination node ${BinaryUtils.toHexString(dstModuleId)} is a subsystem, not a module.`,
+              severity: IssueSeverity.Error,
+            },
+          ])
+        : new ResourceNotFoundException(
+            `Destination module ${BinaryUtils.toHexString(dstModuleId)} not found.`,
+          );
+    }
+    return [srcModule, dstModule] as const;
+  }
+
+  private async findPort(
+    subsystemRepo: ReturnType<UnitOfWork['getSubsystemRepository']>,
+    ports: {systemId: number; portIoType: string}[],
+    portId: number,
+    fileSystemId: number,
+    side: 'Source' | 'Destination',
+  ) {
+    const port = ports.find(p => p.systemId === portId);
+    if (port) return port;
+    if (!(await subsystemRepo.portExists(portId, fileSystemId))) {
+      throw new ResourceNotFoundException(
+        `${side} port ${BinaryUtils.toHexString(portId)} not found.`,
+      );
+    }
+    throw new DomainRuleViolationException([
+      {
+        code: 'PORT_OWNERSHIP_MISMATCH',
+        message: `Port ${BinaryUtils.toHexString(portId)} does not belong to ${side.toLowerCase()} module — ownership check failed.`,
+        severity: IssueSeverity.Error,
+      },
+    ]);
+  }
+
+  private validatePortDirections(
+    srcPort: {portIoType: string},
+    srcPortId: number,
+    dstPort: {portIoType: string},
+    dstPortId: number,
+  ): void {
+    if (srcPort.portIoType !== PORT_IO_TYPE.Output) {
+      throw new DomainRuleViolationException([
+        {
+          code: 'WRONG_PORT_DIRECTION',
+          message: `Source port ${BinaryUtils.toHexString(srcPortId)} must be OUTPUT, got ${srcPort.portIoType}.`,
+          severity: IssueSeverity.Error,
+        },
+      ]);
+    }
+    if (dstPort.portIoType !== PORT_IO_TYPE.Input) {
+      throw new DomainRuleViolationException([
+        {
+          code: 'WRONG_PORT_DIRECTION',
+          message: `Destination port ${BinaryUtils.toHexString(dstPortId)} must be INPUT, got ${dstPort.portIoType}.`,
+          severity: IssueSeverity.Error,
+        },
+      ]);
+    }
+  }
+
+  private async validateInterUsecase(
+    uow: UnitOfWork,
+    srcSubgraphId: number,
+    dstSubgraphId: number,
+    fileSystemId: number,
+  ): Promise<void> {
+    const subgraphRepo = uow.getSubgraphRepository();
+    const [srcUsecaseId, dstUsecaseId] = await Promise.all([
+      subgraphRepo.getUsecaseSystemIdForSubgraph(srcSubgraphId, fileSystemId),
+      subgraphRepo.getUsecaseSystemIdForSubgraph(dstSubgraphId, fileSystemId),
+    ]);
+    if (
+      srcUsecaseId !== null &&
+      dstUsecaseId !== null &&
+      srcUsecaseId === dstUsecaseId
+    ) {
+      throw new DomainRuleViolationException([
+        {
+          code: 'SAME_USECASE_INTER_USECASE',
+          message:
+            'isInterUsecase=true but source and destination belong to the same usecase.',
+          severity: IssueSeverity.Error,
+        },
+      ]);
+    }
+  }
+
+  private deriveLinkType(
+    isInterUsecase: boolean | undefined,
+    srcSubgraphId: number,
+    dstSubgraphId: number,
+  ): LinkType {
+    if (isInterUsecase === true) return LINK_TYPE.InterUsecase;
+    if (srcSubgraphId !== dstSubgraphId) return LINK_TYPE.IntraUsecase;
+    return LINK_TYPE.IntraSubgraph;
+  }
+
+  private buildDto(
+    systemId: number,
+    sourceNodeSystemId: number,
+    destinationNodeSystemId: number,
+    sourcePortSystemId: number,
+    destinationPortSystemId: number,
+    linkType: LinkType,
+    isEc: boolean | undefined,
+  ): ComponentCollectionDto {
+    return {
+      spfModules: [],
+      dataLinks: [
+        mapDataLink({
+          systemId,
+          sourceNodeSystemId,
+          destinationNodeSystemId,
+          sourcePortSystemId,
+          destinationPortSystemId,
+          linkType,
+          isEc: isEc ?? null,
+        }),
+      ],
+      controlLinks: [],
+    };
   }
 }
diff --git a/packages/core/src/application/usecase-designer/usecase/dto/component-collection-dto.ts b/packages/core/src/application/usecase-designer/usecase/dto/component-collection-dto.ts
index 1d06c128d..45b0ba397 100644
--- a/packages/core/src/application/usecase-designer/usecase/dto/component-collection-dto.ts
+++ b/packages/core/src/application/usecase-designer/usecase/dto/component-collection-dto.ts
@@ -17,6 +17,7 @@ import type {
   ComponentsWithSubsystemsReadModel,
   SubsystemNodeReadModel,
 } from '../get-component-with-subsystem/components-with-subsystems-read-model.js';
+import type {SubsystemDataLink} from '../../../../domain/entities/usecase-data/links/subsystem-data-link.js';
 
 export const DataLinkDtoSchema = z.object({
   systemId: z.string().describe('Data link system ID'),
@@ -43,6 +44,20 @@ export const ControlLinkDtoSchema = z.object({
 export type DataLinkDto = z.infer<typeof DataLinkDtoSchema>;
 export type ControlLinkDto = z.infer<typeof ControlLinkDtoSchema>;
 
+export const SubsystemDataLinkDtoSchema = z.object({
+  systemId: z.string().describe('SLS system ID'),
+  sourceNodeSystemId: z.string().describe('Source node system ID'),
+  destinationNodeSystemId: z.string().describe('Destination node system ID'),
+  sourcePortSystemId: z.string().describe('Source port system ID'),
+  destinationPortSystemId: z.string().describe('Destination port system ID'),
+  dataLinkSystemId: z
+    .string()
+    .nullable()
+    .describe('Parent DataLink system ID, null if unresolved'),
+});
+
+export type SubsystemDataLinkDto = z.infer<typeof SubsystemDataLinkDtoSchema>;
+
 export const ComponentCollectionDtoSchema = z.object({
   spfModules: z
     .array(SpfModuleDtoSchema.omit({properties: true}))
@@ -65,7 +80,7 @@ const FilteredKeyDtoSchema = z.object({
 });
 
 // Forward-declared type for mutual recursion in the subsystem tree
-export type SubsystemNodeDto = {
+export type SubsystemComponentsDto = {
   systemId: string;
   name: string;
   filteredKeys: z.infer<typeof FilteredKeyDtoSchema>[];
@@ -73,25 +88,26 @@ export type SubsystemNodeDto = {
 };
 
 export type ComponentCollectionWithSubsystemsDto = ComponentCollectionDto & {
-  subsystems: SubsystemNodeDto[];
+  subsystems: SubsystemComponentsDto[];
 };
 
-export const SubsystemNodeDtoSchema: z.ZodType<SubsystemNodeDto> = z.lazy(() =>
-  z.object({
-    systemId: z.string().describe('Subsystem system ID'),
-    name: z.string().describe('Subsystem name'),
-    filteredKeys: z
-      .array(FilteredKeyDtoSchema)
-      .describe('Keys filtered by this subsystem'),
-    children: ComponentCollectionWithSubsystemsDtoSchema,
-  }),
-);
+export const SubsystemComponentsDtoSchema: z.ZodType<SubsystemComponentsDto> =
+  z.lazy(() =>
+    z.object({
+      systemId: z.string().describe('Subsystem system ID'),
+      name: z.string().describe('Subsystem name'),
+      filteredKeys: z
+        .array(FilteredKeyDtoSchema)
+        .describe('Keys filtered by this subsystem'),
+      children: ComponentCollectionWithSubsystemsDtoSchema,
+    }),
+  );
 
 export const ComponentCollectionWithSubsystemsDtoSchema: z.ZodType<ComponentCollectionWithSubsystemsDto> =
   z.lazy(() =>
     ComponentCollectionDtoSchema.extend({
       subsystems: z
-        .array(SubsystemNodeDtoSchema)
+        .array(SubsystemComponentsDtoSchema)
         .describe('Subsystem hierarchy'),
     }),
   );
@@ -155,7 +171,7 @@ export function mapComponentCollection(
   };
 }
 
-function mapSubsystemNode(sub: SubsystemNodeReadModel): SubsystemNodeDto {
+function mapSubsystemNode(sub: SubsystemNodeReadModel): SubsystemComponentsDto {
   return {
     systemId: String(sub.systemId),
     name: sub.name,
@@ -173,7 +189,40 @@ export function mapComponentCollectionWithSubsystems(
   c: ComponentsWithSubsystemsReadModel,
 ): ComponentCollectionWithSubsystemsDto {
   return {
-    ...mapComponentCollection(c),
+    spfModules: c.modules.map(m => mapSpfModuleForCollection(m)),
+    dataLinks: [
+      ...c.dataLinks.map(l => mapDataLink(l)),
+      ...c.subsystemDataLinks.map(sls => mapSlsToDataLinkDto(sls)),
+    ],
+    controlLinks: c.controlLinks.map(l => mapControlLink(l)),
     subsystems: c.subsystems.map(sub => mapSubsystemNode(sub)),
   };
 }
+
+type SubsystemDataLinkLike = Pick<
+  SubsystemDataLink,
+  | 'systemId'
+  | 'sourceNodeSystemId'
+  | 'destinationNodeSystemId'
+  | 'sourcePortSystemId'
+  | 'destinationPortSystemId'
+>;
+
+export function mapSlsToDataLinkDto(
+  sls: SubsystemDataLinkLike,
+): z.infer<typeof DataLinkDtoSchema> {
+  return {
+    systemId: String(sls.systemId),
+    sourceSystemId: String(sls.sourceNodeSystemId),
+    sourcePortSystemId: String(sls.sourcePortSystemId),
+    destinationSystemId: String(sls.destinationNodeSystemId),
+    destinationPortSystemId: String(sls.destinationPortSystemId),
+    isInterUsecase: false,
+  };
+}
+
+export function mapSubsystemDataLink(
+  sls: SubsystemDataLink,
+): z.infer<typeof DataLinkDtoSchema> {
+  return mapSlsToDataLinkDto(sls);
+}
diff --git a/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/build-subsystem-tree.ts b/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/build-subsystem-tree.ts
index 086c7c522..de405b864 100644
--- a/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/build-subsystem-tree.ts
+++ b/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/build-subsystem-tree.ts
@@ -6,6 +6,7 @@
 import type {SubsystemReadModel} from '../../../ports/persistence/query-services/subsystem/subsystem-read-model.js';
 import type {ComponentsReadModel} from '../../../ports/persistence/query-services/usecase/query-models/components-read-model.js';
 import type {ComponentsWithSubsystemsReadModel} from '../get-component-with-subsystem/components-with-subsystems-read-model.js';
+import type {SubsystemDataLinkReadModel} from '../../../ports/persistence/query-services/usecase/query-models/subsystem-data-link-read-model.js';
 
 /**
  * Builds a recursive subsystem tree from flat loaded data.
@@ -26,6 +27,7 @@ import type {ComponentsWithSubsystemsReadModel} from '../get-component-with-subs
 export function buildSubsystemTree(
   flat: ComponentsReadModel,
   subsystems: SubsystemReadModel[],
+  slsSegments: SubsystemDataLinkReadModel[],
 ): ComponentsWithSubsystemsReadModel {
   const {modules, dataLinks, controlLinks} = flat;
 
@@ -90,6 +92,12 @@ export function buildSubsystemTree(
         levelNodeIds.has(cl.peerNodeBSystemId),
     );
 
+    const levelSubsystemDataLinks = slsSegments.filter(
+      sls =>
+        levelNodeIds.has(sls.sourceNodeSystemId) &&
+        levelNodeIds.has(sls.destinationNodeSystemId),
+    );
+
     const subsystemNodes = directChildIds.flatMap(id => {
       if (visited.has(id)) return []; // skip cycles
       const sub = subsystemById.get(id);
@@ -111,6 +119,7 @@ export function buildSubsystemTree(
       dataLinks: levelDataLinks,
       controlLinks: levelControlLinks,
       subsystems: subsystemNodes,
+      subsystemDataLinks: levelSubsystemDataLinks,
     };
   };
 
diff --git a/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/components-with-subsystems-read-model.ts b/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/components-with-subsystems-read-model.ts
index 12aec198b..1875c8158 100644
--- a/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/components-with-subsystems-read-model.ts
+++ b/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/components-with-subsystems-read-model.ts
@@ -5,6 +5,7 @@
 
 import type {ComponentsReadModel} from '../../../ports/persistence/query-services/usecase/query-models/components-read-model.js';
 import type {KeyDefinitionSummaryReadModel} from '../../../ports/persistence/query-services/key-value/key-value-definition-read-model.js';
+import type {SubsystemDataLinkReadModel} from '../../../ports/persistence/query-services/usecase/query-models/subsystem-data-link-read-model.js';
 
 /**
  * One node in the subsystem tree.
@@ -32,4 +33,5 @@ export interface SubsystemNodeReadModel {
  */
 export interface ComponentsWithSubsystemsReadModel extends ComponentsReadModel {
   readonly subsystems: SubsystemNodeReadModel[];
+  readonly subsystemDataLinks: SubsystemDataLinkReadModel[];
 }
diff --git a/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/get-components-with-subsystems.handler.ts b/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/get-components-with-subsystems.handler.ts
index b5988e7a3..50dedc295 100644
--- a/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/get-components-with-subsystems.handler.ts
+++ b/packages/core/src/application/usecase-designer/usecase/get-component-with-subsystem/get-components-with-subsystems.handler.ts
@@ -7,8 +7,8 @@ import type {QueryHandler} from '../../../orchestration/cqrs/queries/query-handl
 import type {QueryServices} from '../../../ports/persistence/query-services/query-services.js';
 import type {ComponentsWithSubsystemsReadModel} from './components-with-subsystems-read-model.js';
 import type {ComponentsReadModel} from '../../../ports/persistence/query-services/usecase/query-models/components-read-model.js';
-import type {DataLinkReadModel} from '../../../ports/persistence/query-services/link/data-link-read-model.js';
 import type {ControlLinkReadModel} from '../../../ports/persistence/query-services/link/control-link-read-model.js';
+import type {SubsystemDataLinkReadModel} from '../../../ports/persistence/query-services/usecase/query-models/subsystem-data-link-read-model.js';
 import {Result, RESULT_KIND} from '../../../shared/result/result.js';
 import {GetComponentsWithSubsystemsQuery} from './get-components-with-subsystems.query.js';
 import {buildSubsystemTree} from './build-subsystem-tree.js';
@@ -85,9 +85,11 @@ export class GetComponentsWithSubsystemsHandler implements QueryHandler<
     // Boundary-crossing raw links are naturally dropped by levelNodeIds in buildSubsystemTree.
     const subsystemIds = new Set(subsystemsResult.data.map(s => s.systemId));
 
-    // Pass 2b: when subsystems exist, load virtual boundary segments and add to combined list.
+    // Pass 2b: when subsystems exist, load virtual boundary segments separately.
+    // SLS segments (SubsystemDataLinkReadModel) are kept distinct from raw mod-mod dataLinks
+    // so buildSubsystemTree can route them to the correct tree level.
     // Serial dependency on hasSubsystems is intentional — cannot be known before Pass 1.
-    const extraDataLinks: DataLinkReadModel[] = [];
+    let slsSegments: SubsystemDataLinkReadModel[] = [];
     const extraControlLinks: ControlLinkReadModel[] = [];
 
     if (hasSubsystems) {
@@ -111,13 +113,8 @@ export class GetComponentsWithSubsystemsHandler implements QueryHandler<
             'Failed to load virtual control links',
         );
 
-      extraDataLinks.push(
-        ...vDataResult.data.filter(
-          dl =>
-            subsystemIds.has(dl.sourceNodeSystemId) ||
-            subsystemIds.has(dl.destinationNodeSystemId),
-        ),
-      );
+      slsSegments = vDataResult.data;
+
       extraControlLinks.push(
         ...vControlResult.data.filter(
           cl =>
@@ -129,12 +126,13 @@ export class GetComponentsWithSubsystemsHandler implements QueryHandler<
 
     const flat: ComponentsReadModel = {
       modules: modulesResult.data,
-      dataLinks: [...rawDataLinksResult.data, ...extraDataLinks],
+      dataLinks: rawDataLinksResult.data,
       controlLinks: [...rawControlLinksResult.data, ...extraControlLinks],
     };
     const tree: ComponentsWithSubsystemsReadModel = buildSubsystemTree(
       flat,
       subsystemsResult.data,
+      slsSegments,
     );
 
     return Result.ok(mapComponentCollectionWithSubsystems(tree));
diff --git a/packages/core/src/domain/services/subsystem-data-links/subsystem-boundary-path.service.ts b/packages/core/src/domain/services/subsystem-data-links/subsystem-boundary-path.service.ts
deleted file mode 100644
index 59003acc4..000000000
--- a/packages/core/src/domain/services/subsystem-data-links/subsystem-boundary-path.service.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-import {PORT_IO_TYPE} from '../../entities/common/enums/port-io-type.js';
-
-// ---------------------------------------------------------------------------
-// Interfaces (exported — callers depend on these shapes)
-// ---------------------------------------------------------------------------
-
-export interface PathInput {
-  /** node.system_id for the source module */
-  sourceNodeSystemId: number;
-  /** node.system_id for the dest module */
-  destinationNodeSystemId: number;
-  /** All nodes visible in the file: maps node.system_id → node.parentId (null = top level) */
-  nodeParentMap: Map<number, number | null>;
-}
-
-export interface PathOutput {
-  /** Ordered node IDs: [sourceModule, ...subsystemNodes, destModule] */
-  nodeSequence: number[];
-  /**
-   * For each subsystem node in nodeSequence: the PortIoType it must have.
-   * EXIT nodes (signal leaves) → PORT_IO_TYPE.OutputInput
-   * ENTRY nodes (signal enters) → PORT_IO_TYPE.InputOutput
-   */
-  requiredPortType: Map<
-    number,
-    typeof PORT_IO_TYPE.OutputInput | typeof PORT_IO_TYPE.InputOutput
-  >;
-}
-
-// ---------------------------------------------------------------------------
-// Service (static methods only — pure function, no instantiation needed)
-// ---------------------------------------------------------------------------
-
-export const SubsystemBoundaryPathService = {
-  /**
-   * Given two module nodes in different subsystem contexts, computes the
-   * ordered node sequence the signal must pass through and the PortIoType
-   * required at each subsystem boundary.
-   *
-   * Algorithm (spec section 5.1 / OQ-2):
-   * 1. Walk nodeParentMap upward from sourceNodeSystemId → exitChain
-   * 2. Walk nodeParentMap upward from destinationNodeSystemId   → entryChain
-   * 3. Find LCA — first entry shared by both chains (null = top level if none)
-   * 4. Trim both chains at LCA (exclusive)
-   * 5. Reverse entryChain (LCA-level down to dest's immediate parent)
-   * 6. Assemble nodeSequence
-   * 7. Assign requiredPortType per chain membership
-   */
-  compute(input: PathInput): PathOutput {
-    const {sourceNodeSystemId, destinationNodeSystemId, nodeParentMap} = input;
-
-    // Step 1: build exitChain (ancestors of source, innermost first)
-    const exitChain: number[] = [];
-    let cursor: number | null = nodeParentMap.get(sourceNodeSystemId) ?? null;
-    while (cursor !== null) {
-      exitChain.push(cursor);
-      cursor = nodeParentMap.get(cursor) ?? null;
-    }
-
-    // Step 2: build entryChain (ancestors of dest, innermost first)
-    const entryChain: number[] = [];
-    cursor = nodeParentMap.get(destinationNodeSystemId) ?? null;
-    while (cursor !== null) {
-      entryChain.push(cursor);
-      cursor = nodeParentMap.get(cursor) ?? null;
-    }
-
-    // Step 3: find LCA — first node in exitChain that also appears in entryChain
-    // A null LCA means the two chains share no common ancestor (both reach top level
-    // without meeting), or one/both chains are empty (module already at top level).
-    const entryChainSet = new Set<number>(entryChain);
-    let lca: number | null = null;
-    for (const node of exitChain) {
-      if (entryChainSet.has(node)) {
-        lca = node;
-        break;
-      }
-    }
-
-    // Step 4: trim both chains at LCA (exclusive — LCA itself is not a boundary node)
-    const trimmedExit =
-      lca === null ? exitChain : exitChain.slice(0, exitChain.indexOf(lca));
-
-    const trimmedEntry =
-      lca === null ? entryChain : entryChain.slice(0, entryChain.indexOf(lca));
-
-    const reversedEntry = trimmedEntry.toReversed();
-
-    // Step 6: assemble nodeSequence
-    const nodeSequence: number[] = [
-      sourceNodeSystemId,
-      ...trimmedExit,
-      ...reversedEntry,
-      destinationNodeSystemId,
-    ];
-
-    // Step 7: assign requiredPortType
-    const requiredPortType = new Map<
-      number,
-      typeof PORT_IO_TYPE.OutputInput | typeof PORT_IO_TYPE.InputOutput
-    >();
-
-    for (const node of trimmedExit) {
-      requiredPortType.set(node, PORT_IO_TYPE.OutputInput);
-    }
-    for (const node of reversedEntry) {
-      requiredPortType.set(node, PORT_IO_TYPE.InputOutput);
-    }
-
-    return {nodeSequence, requiredPortType};
-  },
-} as const;
diff --git a/packages/core/src/domain/services/subsystem-data-links/subsystem-data-link-derivation.service.ts b/packages/core/src/domain/services/subsystem-data-links/subsystem-data-link-derivation.service.ts
new file mode 100644
index 000000000..c8c7f89c0
--- /dev/null
+++ b/packages/core/src/domain/services/subsystem-data-links/subsystem-data-link-derivation.service.ts
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import {PORT_IO_TYPE} from '../../entities/common/enums/port-io-type.js';
+import type {PortIoType} from '../../entities/common/enums/port-io-type.js';
+
+export interface SegmentDescriptor {
+  sourceNodeSystemId: number;
+  destinationNodeSystemId: number;
+  sourceBoundaryPortType: PortIoType | null;
+  destBoundaryPortType: PortIoType | null;
+  position: number;
+}
+
+export interface DerivationInput {
+  sourceNodeSystemId: number;
+  destinationNodeSystemId: number;
+  nodeParentMap: Map<number, number | null>;
+}
+
+export const SubsystemDataLinkDerivationService = {
+  /**
+   * Computes the ordered list of SLS segments for a data link crossing
+   * subsystem boundaries. Returns [] if source and dest share the same
+   * subsystem context (no boundary crossing needed).
+   *
+   * Each segment describes one hop in the chain: which nodes it connects and
+   * the PortIoType required at each end (null = module endpoint, not a
+   * boundary port).
+   */
+  compute(input: DerivationInput): SegmentDescriptor[] {
+    const {
+      sourceNodeSystemId: sourceNodeId,
+      destinationNodeSystemId: destNodeId,
+      nodeParentMap,
+    } = input;
+
+    // Build exit chain: ancestors of source (innermost first)
+    const exitChain: number[] = [];
+    let cursor: number | null = nodeParentMap.get(sourceNodeId) ?? null;
+    while (cursor !== null) {
+      exitChain.push(cursor);
+      cursor = nodeParentMap.get(cursor) ?? null;
+    }
+
+    // Build entry chain: ancestors of dest (innermost first)
+    const entryChain: number[] = [];
+    cursor = nodeParentMap.get(destNodeId) ?? null;
+    while (cursor !== null) {
+      entryChain.push(cursor);
+      cursor = nodeParentMap.get(cursor) ?? null;
+    }
+
+    // Find LCA — first node in exitChain that also appears in entryChain
+    const entrySet = new Set(entryChain);
+    let lca: number | null = null;
+    for (const node of exitChain) {
+      if (entrySet.has(node)) {
+        lca = node;
+        break;
+      }
+    }
+
+    // Trim both chains at LCA (exclusive — LCA itself is not a boundary node)
+    const trimmedExit =
+      lca === null ? exitChain : exitChain.slice(0, exitChain.indexOf(lca));
+    const trimmedEntry =
+      lca === null ? entryChain : entryChain.slice(0, entryChain.indexOf(lca));
+    const reversedEntry = trimmedEntry.toReversed();
+
+    const nodeSequence = [
+      sourceNodeId,
+      ...trimmedExit,
+      ...reversedEntry,
+      destNodeId,
+    ];
+
+    // No boundary crossing if source and dest are in the same context
+    if (nodeSequence.length <= 2) return [];
+
+    // Assign required port types: exit nodes → OutputInput, entry nodes → InputOutput
+    const requiredPortType = new Map<number, PortIoType>();
+    for (const n of trimmedExit)
+      requiredPortType.set(n, PORT_IO_TYPE.OutputInput);
+    for (const n of reversedEntry)
+      requiredPortType.set(n, PORT_IO_TYPE.InputOutput);
+
+    const segments: SegmentDescriptor[] = [];
+    for (let i = 0; i < nodeSequence.length - 1; i++) {
+      segments.push({
+        sourceNodeSystemId: nodeSequence[i],
+        destinationNodeSystemId: nodeSequence[i + 1],
+        sourceBoundaryPortType:
+          i === 0 ? null : (requiredPortType.get(nodeSequence[i]) ?? null),
+        destBoundaryPortType:
+          i === nodeSequence.length - 2
+            ? null
+            : (requiredPortType.get(nodeSequence[i + 1]) ?? null),
+        position: i,
+      });
+    }
+    return segments;
+  },
+} as const;
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index f7fc96e75..7c4b9d95c 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -73,6 +73,7 @@ export type {
 export type {
   DataLinkRepository,
   SubsystemDataRouteContext,
+  BoundaryPortPayload,
 } from './application/ports/persistence/repositories/data-link/data-link.repository.js';
 export type {ControlLinkRepository} from './application/ports/persistence/repositories/control-link/control-link.repository.js';
 export type {SubgraphRepository} from './application/ports/persistence/repositories/subgraph/subgraph.repository.js';
@@ -116,6 +117,7 @@ export * from './application/ports/persistence/query-services/link/control-link-
 export * from './application/ports/persistence/query-services/subsystem/subsystem-query-service.js';
 export * from './application/ports/persistence/query-services/subsystem/subsystem-read-model.js';
 export * from './application/ports/persistence/query-services/usecase/query-models/components-read-model.js';
+export * from './application/ports/persistence/query-services/usecase/query-models/subsystem-data-link-read-model.js';
 export * from './application/usecase-designer/usecase/get-component-with-subsystem/components-with-subsystems-read-model.js';
 
 // Filter expression (shared filter AST — no framework deps)
@@ -459,9 +461,11 @@ export type {
   ComponentCollectionWithSubsystemsDto,
   DataLinkDto,
   ControlLinkDto,
+  SubsystemComponentsDto,
 } from './application/usecase-designer/usecase/dto/component-collection-dto.js';
+export {SubsystemComponentsDtoSchema} from './application/usecase-designer/usecase/dto/component-collection-dto.js';
 export * from './application/usecase-designer/data-links/create/create-data-link.command.js';
-export * from './application/usecase-designer/data-links/create/create-data-link.handler.js';
+export * from './application/usecase-designer/data-links/create/create-data-link-with-subsystems.command.js';
 export * from './application/usecase-designer/data-links/delete/delete-data-link.command.js';
 export * from './application/usecase-designer/data-links/delete/delete-data-link.handler.js';
 export * from './application/usecase-designer/control-links/create/create-control-link.command.js';
diff --git a/packages/core/src/shared/exceptions/conflict.exception.ts b/packages/core/src/shared/exceptions/conflict.exception.ts
new file mode 100644
index 000000000..f5fbee520
--- /dev/null
+++ b/packages/core/src/shared/exceptions/conflict.exception.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import {DomainException} from './domain-exception.js';
+
+/**
+ * Thrown when an operation would create a duplicate resource that must be unique.
+ *
+ * Maps to HTTP 409 Conflict via AllExceptionsFilter.
+ *
+ * @example
+ * throw new ConflictException(`DataLink for ports (${src}, ${dst}) already exists.`);
+ */
+export class ConflictException extends DomainException {
+  readonly errorCode = 'CONFLICT';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
diff --git a/packages/core/src/shared/exceptions/index.ts b/packages/core/src/shared/exceptions/index.ts
index 11fe76c45..9ebdde045 100644
--- a/packages/core/src/shared/exceptions/index.ts
+++ b/packages/core/src/shared/exceptions/index.ts
@@ -9,3 +9,4 @@ export {InvalidOperationException} from './invalid-operation.exception.js';
 export {DomainNotImplementedException} from './not-implemented.exception.js';
 export {DomainRuleViolationException} from './domain-rule-violation.exception.js';
 export {StagedChangesExistException} from './staged-changes-exist.exception.js';
+export {ConflictException} from './conflict.exception.js';
diff --git a/packages/core/tests/unit/application/file-operations/upload-file/services/entity-builders/subsystem-builder.spec.ts b/packages/core/tests/unit/application/file-operations/upload-file/services/entity-builders/subsystem-builder.spec.ts
index 1d71bdcdd..8a49f86b2 100644
--- a/packages/core/tests/unit/application/file-operations/upload-file/services/entity-builders/subsystem-builder.spec.ts
+++ b/packages/core/tests/unit/application/file-operations/upload-file/services/entity-builders/subsystem-builder.spec.ts
@@ -360,7 +360,7 @@ describe('SubsystemBuilder — boundary ports', () => {
       expect(output.paths[0]).toBeNull();
     });
 
-    it('returns a path for cross-subsystem links', () => {
+    it('returns descriptors for cross-subsystem links', () => {
       const output = SubsystemBuilder.computePaths({
         links: [{systemId: 1, nodeANaturalId: 100, nodeBNaturalId: 200}],
         nodeParentMapEntries: [
@@ -372,7 +372,21 @@ describe('SubsystemBuilder — boundary ports', () => {
       });
       const path = output.paths[0];
       expect(path).not.toBeNull();
-      expect(path!.nodeSequence).toEqual([100, 10, 20, 200]);
+      expect(path).toEqual({
+        linkSystemId: 1,
+        segments: expect.arrayContaining([
+          expect.objectContaining({
+            sourceNodeSystemId: 100,
+            destinationNodeSystemId: 10,
+            position: 0,
+          }),
+          expect.objectContaining({
+            sourceNodeSystemId: 20,
+            destinationNodeSystemId: 200,
+            position: 2,
+          }),
+        ]),
+      });
     });
 
     it('reconstructs nodeParentMap from entries correctly for multi-hop', () => {
@@ -388,7 +402,8 @@ describe('SubsystemBuilder — boundary ports', () => {
       });
       const path = output.paths[0];
       expect(path).not.toBeNull();
-      expect(path!.nodeSequence).toHaveLength(5);
+      // nodeSequence would be [100, 10, 20, 30, 200] → 4 segments
+      expect(path!.segments).toHaveLength(4);
     });
   });
 });
diff --git a/packages/core/tests/unit/application/usecase-designer/data-links/create/create-data-link-with-subsystems.handler.spec.ts b/packages/core/tests/unit/application/usecase-designer/data-links/create/create-data-link-with-subsystems.handler.spec.ts
new file mode 100644
index 000000000..b1d54501b
--- /dev/null
+++ b/packages/core/tests/unit/application/usecase-designer/data-links/create/create-data-link-with-subsystems.handler.spec.ts
@@ -0,0 +1,327 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import {describe, it, expect, jest, beforeEach} from '@jest/globals';
+import {CreateDataLinkWithSubsystemsHandler} from '../../../../../../src/application/usecase-designer/data-links/create/create-data-link-with-subsystems.handler.js';
+import {CreateDataLinkWithSubsystemsCommand} from '../../../../../../src/application/usecase-designer/data-links/create/create-data-link-with-subsystems.command.js';
+import type {
+  UnitOfWork,
+  IdGenerationPort,
+  DataLinkRepository,
+  SubsystemRepository,
+  ModuleRepository,
+  PortIoType,
+} from '@arc/core';
+
+const FILE_ID = 10;
+const GROUP_ID = 'gid';
+const MOD_A = '201';
+const MOD_B = '202';
+const SUBSYS_A = '501';
+const PORT_SRC = '301';
+const PORT_DST = '302';
+const PORT_SUBSYS_OUT = '401';
+
+function makeDlEditRepo(): DataLinkRepository {
+  return {
+    createDataLink: jest.fn().mockResolvedValue(undefined),
+    findByPortPair: jest.fn().mockResolvedValue(null),
+    reactivateDataLink: jest.fn().mockResolvedValue(undefined),
+    createSubsystemDataLink: jest.fn().mockResolvedValue(undefined),
+  } as unknown as DataLinkRepository;
+}
+
+function makeModuleRepo(
+  overrides: {
+    src?: {
+      subgraphSystemId: number;
+      ports: {systemId: number; portIoType: PortIoType}[];
+    } | null;
+    dst?: {
+      subgraphSystemId: number;
+      ports: {systemId: number; portIoType: PortIoType}[];
+    } | null;
+  } = {},
+): ModuleRepository {
+  const srcDefault = {
+    subgraphSystemId: 11,
+    ports: [{systemId: 301, portIoType: 'OUTPUT' as PortIoType}],
+  };
+  const dstDefault = {
+    subgraphSystemId: 22,
+    ports: [{systemId: 302, portIoType: 'INPUT' as PortIoType}],
+  };
+  return {
+    findModulePortsForLink: jest.fn().mockImplementation(async (id: number) => {
+      if (id === Number(MOD_A))
+        return overrides.src !== undefined ? overrides.src : srcDefault;
+      if (id === Number(MOD_B))
+        return overrides.dst !== undefined ? overrides.dst : dstDefault;
+      return null;
+    }),
+    findModuleForPatch: jest.fn(),
+  } as unknown as ModuleRepository;
+}
+
+function makeSubsystemRepo(subsystemIds: number[] = []): SubsystemRepository {
+  return {
+    subsystemExists: jest
+      .fn()
+      .mockImplementation(async (id: number) => subsystemIds.includes(id)),
+    getAllNodesWithParents: jest.fn().mockResolvedValue(
+      new Map<number, number | null>([
+        [201, null],
+        [202, null],
+      ]),
+    ),
+    getPortIoType: jest.fn().mockResolvedValue(null),
+    isPortOccupiedAsSource: jest.fn().mockResolvedValue(false),
+    isPortOccupiedAsDest: jest.fn().mockResolvedValue(false),
+  } as unknown as SubsystemRepository;
+}
+
+function makeUow(
+  overrides: {
+    dlEditRepo?: DataLinkRepository;
+    subsystemRepo?: SubsystemRepository;
+    moduleRepo?: ModuleRepository;
+  } = {},
+): UnitOfWork {
+  return {
+    startTransaction: jest.fn().mockResolvedValue(undefined),
+    commit: jest.fn().mockResolvedValue(undefined),
+    rollback: jest.fn().mockResolvedValue(undefined),
+    isInTransaction: jest.fn().mockReturnValue(true),
+    getWriteContext: jest.fn().mockReturnValue({
+      session: {sessionId: 1, fileSystemId: FILE_ID},
+      groupId: GROUP_ID,
+    }),
+    setWriteContext: jest.fn(),
+    applyCachedActions: jest.fn(),
+    getSessionRepository: jest.fn(),
+    getBulkImportRepository: jest.fn(),
+    getProjectRepository: jest.fn(),
+    getValidationPreferencesRepository: jest.fn(),
+    getValidationQueryService: jest.fn(),
+    getModuleRepository: jest
+      .fn()
+      .mockReturnValue(overrides.moduleRepo ?? makeModuleRepo()),
+    getContainerRepository: jest.fn(),
+    getModuleDefinitionRepository: jest.fn(),
+    getDataLinkRepository: jest
+      .fn()
+      .mockReturnValue(overrides.dlEditRepo ?? makeDlEditRepo()),
+    getControlLinkRepository: jest.fn(),
+    getSubgraphRepository: jest.fn(),
+    getSubsystemRepository: jest
+      .fn()
+      .mockReturnValue(overrides.subsystemRepo ?? makeSubsystemRepo()),
+    getPropertyDefinitionsRepository: jest.fn(),
+  } as unknown as UnitOfWork;
+}
+
+let idSeq = 500;
+function makeIdGen(): IdGenerationPort {
+  return {
+    getNextId: jest.fn().mockImplementation(() => Promise.resolve(idSeq++)),
+  } as unknown as IdGenerationPort;
+}
+
+describe('CreateDataLinkWithSubsystemsHandler', () => {
+  beforeEach(() => {
+    idSeq = 500;
+  });
+
+  // ── Self-loop check ──────────────────────────────────────────────────────
+
+  it('throws 422 when source === dest node (self-loop, FR-DLS-04)', async () => {
+    const handler = new CreateDataLinkWithSubsystemsHandler(
+      makeUow(),
+      makeIdGen(),
+    );
+    await expect(
+      handler.handle(
+        new CreateDataLinkWithSubsystemsCommand(
+          MOD_A,
+          PORT_SRC,
+          MOD_A,
+          PORT_DST,
+        ),
+      ),
+    ).rejects.toThrow('must differ');
+  });
+
+  // ── Branch A (both module endpoints, FR-DLS-10) ──────────────────────────
+
+  describe('Branch A (both module endpoints, FR-DLS-10)', () => {
+    it('calls createDataLink, returns dataLinks empty, does not throw', async () => {
+      const dlRepo = makeDlEditRepo();
+      const moduleRepo = makeModuleRepo();
+      const subsysRepo = makeSubsystemRepo([]);
+      const uow = makeUow({
+        dlEditRepo: dlRepo,
+        subsystemRepo: subsysRepo,
+        moduleRepo,
+      });
+      const handler = new CreateDataLinkWithSubsystemsHandler(uow, makeIdGen());
+
+      const result = await handler.handle(
+        new CreateDataLinkWithSubsystemsCommand(
+          MOD_A,
+          PORT_SRC,
+          MOD_B,
+          PORT_DST,
+        ),
+      );
+
+      expect(dlRepo.createDataLink).toHaveBeenCalledTimes(1);
+      expect(result.dataLinks).toHaveLength(0);
+    });
+
+    it('throws 409 when duplicate active DataLink exists (Branch A)', async () => {
+      const dlRepo = makeDlEditRepo();
+      (dlRepo.findByPortPair as ReturnType<typeof jest.fn>).mockResolvedValue({
+        systemId: 1,
+        isDeleted: false,
+        payload: {},
+      });
+      const moduleRepo = makeModuleRepo();
+      const subsysRepo = makeSubsystemRepo([]);
+      const handler = new CreateDataLinkWithSubsystemsHandler(
+        makeUow({dlEditRepo: dlRepo, subsystemRepo: subsysRepo, moduleRepo}),
+        makeIdGen(),
+      );
+      await expect(
+        handler.handle(
+          new CreateDataLinkWithSubsystemsCommand(
+            MOD_A,
+            PORT_SRC,
+            MOD_B,
+            PORT_DST,
+          ),
+        ),
+      ).rejects.toThrow('already exists');
+    });
+
+    it('throws 422 when source port direction is wrong (FR-DLS-05)', async () => {
+      const moduleRepo = makeModuleRepo({
+        src: {
+          subgraphSystemId: 11,
+          ports: [{systemId: 301, portIoType: 'INPUT' as PortIoType}],
+        },
+      });
+      const subsysRepo = makeSubsystemRepo([]);
+      const handler = new CreateDataLinkWithSubsystemsHandler(
+        makeUow({subsystemRepo: subsysRepo, moduleRepo}),
+        makeIdGen(),
+      );
+      await expect(
+        handler.handle(
+          new CreateDataLinkWithSubsystemsCommand(
+            MOD_A,
+            PORT_SRC,
+            MOD_B,
+            PORT_DST,
+          ),
+        ),
+      ).rejects.toThrow('OUTPUT');
+    });
+  });
+
+  // ── Branch B (subsystem endpoint, FR-DLS-11) ────────────────────────────
+
+  describe('Branch B (subsystem endpoint, FR-DLS-11)', () => {
+    it('calls createSubsystemDataLink and not createDataLink when source is subsystem', async () => {
+      const dlRepo = makeDlEditRepo();
+      const subsysRepo = makeSubsystemRepo([Number(SUBSYS_A)]);
+      (
+        subsysRepo.getPortIoType as ReturnType<typeof jest.fn>
+      ).mockResolvedValue('INPUT_OUTPUT');
+      const uow = makeUow({dlEditRepo: dlRepo, subsystemRepo: subsysRepo});
+      const handler = new CreateDataLinkWithSubsystemsHandler(uow, makeIdGen());
+
+      const result = await handler.handle(
+        new CreateDataLinkWithSubsystemsCommand(
+          SUBSYS_A,
+          PORT_SUBSYS_OUT,
+          MOD_B,
+          PORT_DST,
+        ),
+      );
+
+      expect(dlRepo.createSubsystemDataLink).toHaveBeenCalledTimes(1);
+      expect(dlRepo.createDataLink).not.toHaveBeenCalled();
+      expect(result.dataLinks).toHaveLength(1);
+      expect(result.dataLinks[0].sourceSystemId).toBe(SUBSYS_A);
+    });
+
+    it('throws 422 when isInterUsecase is provided and one endpoint is a subsystem (FR-DLS-11)', async () => {
+      const subsysRepo = makeSubsystemRepo([Number(SUBSYS_A)]);
+      const handler = new CreateDataLinkWithSubsystemsHandler(
+        makeUow({subsystemRepo: subsysRepo}),
+        makeIdGen(),
+      );
+
+      await expect(
+        handler.handle(
+          new CreateDataLinkWithSubsystemsCommand(
+            SUBSYS_A,
+            PORT_SUBSYS_OUT,
+            MOD_B,
+            PORT_DST,
+            true,
+          ),
+        ),
+      ).rejects.toThrow('must not be provided');
+    });
+
+    it('throws 422 when source subsystem port is already occupied as source (FR-DLS-07)', async () => {
+      const dlRepo = makeDlEditRepo();
+      const subsysRepo = makeSubsystemRepo([Number(SUBSYS_A)]);
+      (
+        subsysRepo.getPortIoType as ReturnType<typeof jest.fn>
+      ).mockResolvedValue('INPUT_OUTPUT');
+      (
+        subsysRepo.isPortOccupiedAsSource as ReturnType<typeof jest.fn>
+      ).mockResolvedValue(true);
+      const handler = new CreateDataLinkWithSubsystemsHandler(
+        makeUow({dlEditRepo: dlRepo, subsystemRepo: subsysRepo}),
+        makeIdGen(),
+      );
+      await expect(
+        handler.handle(
+          new CreateDataLinkWithSubsystemsCommand(
+            SUBSYS_A,
+            PORT_SUBSYS_OUT,
+            MOD_B,
+            PORT_DST,
+          ),
+        ),
+      ).rejects.toThrow('occupied');
+    });
+
+    it('throws 422 when source subsystem port has wrong portIoType (FR-DLS-08)', async () => {
+      const dlRepo = makeDlEditRepo();
+      const subsysRepo = makeSubsystemRepo([Number(SUBSYS_A)]);
+      (
+        subsysRepo.getPortIoType as ReturnType<typeof jest.fn>
+      ).mockResolvedValue('OUTPUT');
+      const handler = new CreateDataLinkWithSubsystemsHandler(
+        makeUow({dlEditRepo: dlRepo, subsystemRepo: subsysRepo}),
+        makeIdGen(),
+      );
+      await expect(
+        handler.handle(
+          new CreateDataLinkWithSubsystemsCommand(
+            SUBSYS_A,
+            PORT_SUBSYS_OUT,
+            MOD_B,
+            PORT_DST,
+          ),
+        ),
+      ).rejects.toThrow('InputOutput');
+    });
+  });
+});
diff --git a/packages/core/tests/unit/application/usecase-designer/data-links/create/create-data-link.handler.spec.ts b/packages/core/tests/unit/application/usecase-designer/data-links/create/create-data-link.handler.spec.ts
new file mode 100644
index 000000000..87f75deab
--- /dev/null
+++ b/packages/core/tests/unit/application/usecase-designer/data-links/create/create-data-link.handler.spec.ts
@@ -0,0 +1,289 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import {describe, it, expect, jest, beforeEach} from '@jest/globals';
+import {CreateDataLinkHandler} from '../../../../../../src/application/usecase-designer/data-links/create/create-data-link.handler.js';
+import {CreateDataLinkCommand} from '../../../../../../src/application/usecase-designer/data-links/create/create-data-link.command.js';
+import {ConflictException, DomainRuleViolationException} from '@arc/core';
+import type {
+  UnitOfWork,
+  IdGenerationPort,
+  DataLinkRepository,
+  SubsystemRepository,
+  ModuleRepository,
+  PortIoType,
+} from '@arc/core';
+
+const FILE_ID = 10;
+const GROUP_ID = 'test-group-uuid';
+const SRC_MODULE = '201';
+const DST_MODULE = '202';
+const SRC_PORT = '301';
+const DST_PORT = '302';
+
+const PORT_IO_TYPE_OUT = 'OUTPUT' as PortIoType;
+const PORT_IO_TYPE_IN = 'INPUT' as PortIoType;
+
+function makeDataLinkEditRepo(
+  findResult: {
+    systemId: number;
+    isDeleted: boolean;
+    payload: Record<string, unknown>;
+  } | null = null,
+): DataLinkRepository {
+  return {
+    createDataLink: jest.fn().mockResolvedValue(undefined),
+    findByPortPair: jest.fn().mockResolvedValue(findResult),
+    reactivateDataLink: jest.fn().mockResolvedValue(undefined),
+    createSubsystemDataLink: jest.fn().mockResolvedValue(undefined),
+  } as unknown as DataLinkRepository;
+}
+
+function makeModuleRepo(
+  overrides: {
+    src?: {
+      subgraphSystemId: number;
+      ports: {systemId: number; portIoType: PortIoType}[];
+    } | null;
+    dst?: {
+      subgraphSystemId: number;
+      ports: {systemId: number; portIoType: PortIoType}[];
+    } | null;
+  } = {},
+): ModuleRepository {
+  const srcDefault = {
+    subgraphSystemId: 11,
+    ports: [{systemId: 301, portIoType: PORT_IO_TYPE_OUT}],
+  };
+  const dstDefault = {
+    subgraphSystemId: 22,
+    ports: [{systemId: 302, portIoType: PORT_IO_TYPE_IN}],
+  };
+  return {
+    findModulePortsForLink: jest.fn().mockImplementation(async (id: number) => {
+      if (id === 201)
+        return overrides.src !== undefined ? overrides.src : srcDefault;
+      if (id === 202)
+        return overrides.dst !== undefined ? overrides.dst : dstDefault;
+      return null;
+    }),
+    findModuleForPatch: jest.fn().mockResolvedValue(null),
+  } as unknown as ModuleRepository;
+}
+
+function makeSubsystemRepo(subsystemIds: number[] = []): SubsystemRepository {
+  return {
+    subsystemExists: jest
+      .fn()
+      .mockImplementation(async (id: number) => subsystemIds.includes(id)),
+    getAllNodesWithParents: jest.fn().mockResolvedValue(
+      new Map<number, number | null>([
+        [201, null],
+        [202, null],
+      ]),
+    ),
+    getPortIoType: jest.fn().mockResolvedValue(null),
+    isPortOccupiedAsSource: jest.fn().mockResolvedValue(false),
+    isPortOccupiedAsDest: jest.fn().mockResolvedValue(false),
+    portExists: jest.fn().mockResolvedValue(true),
+  } as unknown as SubsystemRepository;
+}
+
+function makeUow(
+  overrides: {
+    dlEditRepo?: DataLinkRepository;
+    subsystemRepo?: SubsystemRepository;
+    moduleRepo?: ModuleRepository;
+  } = {},
+): UnitOfWork {
+  return {
+    startTransaction: jest.fn().mockResolvedValue(undefined),
+    commit: jest.fn().mockResolvedValue(undefined),
+    rollback: jest.fn().mockResolvedValue(undefined),
+    isInTransaction: jest.fn().mockReturnValue(true),
+    getWriteContext: jest.fn().mockReturnValue({
+      session: {sessionId: 1, fileSystemId: FILE_ID, mode: 'DESIGNER'},
+      groupId: GROUP_ID,
+    }),
+    setWriteContext: jest.fn(),
+    applyCachedActions: jest.fn().mockResolvedValue(undefined),
+    getSessionRepository: jest.fn(),
+    getBulkImportRepository: jest.fn(),
+    getProjectRepository: jest.fn(),
+    getValidationPreferencesRepository: jest.fn(),
+    getValidationQueryService: jest.fn(),
+    getModuleRepository: jest
+      .fn()
+      .mockReturnValue(overrides.moduleRepo ?? makeModuleRepo()),
+    getContainerRepository: jest.fn(),
+    getModuleDefinitionRepository: jest.fn(),
+    getDataLinkRepository: jest
+      .fn()
+      .mockReturnValue(overrides.dlEditRepo ?? makeDataLinkEditRepo()),
+    getControlLinkRepository: jest.fn(),
+    getSubgraphRepository: jest.fn(),
+    getSubsystemRepository: jest
+      .fn()
+      .mockReturnValue(overrides.subsystemRepo ?? makeSubsystemRepo()),
+    getPropertyDefinitionsRepository: jest.fn(),
+  } as unknown as UnitOfWork;
+}
+
+let idSeq = 500;
+function makeIdGen(): IdGenerationPort {
+  return {
+    getNextId: jest.fn().mockImplementation(() => Promise.resolve(idSeq++)),
+  } as unknown as IdGenerationPort;
+}
+
+describe('CreateDataLinkHandler', () => {
+  beforeEach(() => {
+    idSeq = 500;
+  });
+
+  it('creates a DataLink and returns UseCaseComponentsReadModel with one dataLink', async () => {
+    const dlRepo = makeDataLinkEditRepo(null);
+    const uow = makeUow({dlEditRepo: dlRepo});
+    const handler = new CreateDataLinkHandler(uow, makeIdGen());
+
+    const result = await handler.handle(
+      new CreateDataLinkCommand(SRC_MODULE, SRC_PORT, DST_MODULE, DST_PORT),
+    );
+
+    expect(dlRepo.createDataLink).toHaveBeenCalledTimes(1);
+    expect(uow.commit as ReturnType<typeof jest.fn>).toHaveBeenCalled();
+    expect(result.dataLinks).toHaveLength(1);
+    expect(result.dataLinks[0].sourcePortSystemId).toBe('301');
+    expect(result.dataLinks[0].destinationPortSystemId).toBe('302');
+  });
+
+  it('throws ConflictException (409) when an active DataLink already exists for the port pair', async () => {
+    const dlRepo = makeDataLinkEditRepo({
+      systemId: 999,
+      isDeleted: false,
+      payload: {},
+    });
+    const uow = makeUow({dlEditRepo: dlRepo});
+    const handler = new CreateDataLinkHandler(uow, makeIdGen());
+
+    await expect(
+      handler.handle(
+        new CreateDataLinkCommand(SRC_MODULE, SRC_PORT, DST_MODULE, DST_PORT),
+      ),
+    ).rejects.toThrow('already exists');
+  });
+
+  it('calls reactivateDataLink and not createDataLink when a soft-deleted link exists (FR-DL-07a)', async () => {
+    const dlRepo = makeDataLinkEditRepo({
+      systemId: 888,
+      isDeleted: true,
+      payload: {
+        sourcePortSystemId: 301,
+        destinationPortSystemId: 302,
+        fileSystemId: FILE_ID,
+      },
+    });
+    const uow = makeUow({dlEditRepo: dlRepo});
+    const handler = new CreateDataLinkHandler(uow, makeIdGen());
+
+    await handler.handle(
+      new CreateDataLinkCommand(SRC_MODULE, SRC_PORT, DST_MODULE, DST_PORT),
+    );
+
+    expect(dlRepo.reactivateDataLink).toHaveBeenCalledTimes(1);
+  });
+
+  it('throws DomainRuleViolationException (422) when source === destination module (self-loop, FR-DL-06)', async () => {
+    const handler = new CreateDataLinkHandler(makeUow(), makeIdGen());
+    await expect(
+      handler.handle(
+        new CreateDataLinkCommand(SRC_MODULE, SRC_PORT, SRC_MODULE, DST_PORT),
+      ),
+    ).rejects.toThrow('must differ');
+  });
+
+  // ── FR-DL-02/03/04/05 validations ────────────────────────────────────────
+
+  it('throws ResourceNotFoundException (404) when source module does not exist (FR-DL-03)', async () => {
+    const moduleRepo = makeModuleRepo({src: null});
+    const handler = new CreateDataLinkHandler(
+      makeUow({moduleRepo}),
+      makeIdGen(),
+    );
+    await expect(
+      handler.handle(
+        new CreateDataLinkCommand(SRC_MODULE, SRC_PORT, DST_MODULE, DST_PORT),
+      ),
+    ).rejects.toThrow('not found');
+  });
+
+  it('throws DomainRuleViolationException (422) when source is a subsystem node (FR-DL-02)', async () => {
+    const moduleRepo = makeModuleRepo({src: null});
+    const subsysRepo = makeSubsystemRepo([201]);
+    const handler = new CreateDataLinkHandler(
+      makeUow({moduleRepo, subsystemRepo: subsysRepo}),
+      makeIdGen(),
+    );
+    await expect(
+      handler.handle(
+        new CreateDataLinkCommand(SRC_MODULE, SRC_PORT, DST_MODULE, DST_PORT),
+      ),
+    ).rejects.toThrow('subsystem');
+  });
+
+  it('throws DomainRuleViolationException (422) when source port direction is not OUTPUT (FR-DL-04)', async () => {
+    const moduleRepo = makeModuleRepo({
+      src: {
+        subgraphSystemId: 11,
+        ports: [{systemId: 301, portIoType: PORT_IO_TYPE_IN}],
+      },
+    });
+    const handler = new CreateDataLinkHandler(
+      makeUow({moduleRepo}),
+      makeIdGen(),
+    );
+    await expect(
+      handler.handle(
+        new CreateDataLinkCommand(SRC_MODULE, SRC_PORT, DST_MODULE, DST_PORT),
+      ),
+    ).rejects.toThrow('OUTPUT');
+  });
+
+  it('throws DomainRuleViolationException (422) when dest port direction is not INPUT (FR-DL-04)', async () => {
+    const moduleRepo = makeModuleRepo({
+      dst: {
+        subgraphSystemId: 22,
+        ports: [{systemId: 302, portIoType: PORT_IO_TYPE_OUT}],
+      },
+    });
+    const handler = new CreateDataLinkHandler(
+      makeUow({moduleRepo}),
+      makeIdGen(),
+    );
+    await expect(
+      handler.handle(
+        new CreateDataLinkCommand(SRC_MODULE, SRC_PORT, DST_MODULE, DST_PORT),
+      ),
+    ).rejects.toThrow('INPUT');
+  });
+
+  it('throws DomainRuleViolationException (422) when source port does not belong to source module (FR-DL-05)', async () => {
+    const moduleRepo = makeModuleRepo({
+      src: {
+        subgraphSystemId: 11,
+        ports: [{systemId: 999, portIoType: PORT_IO_TYPE_OUT}],
+      },
+    });
+    const handler = new CreateDataLinkHandler(
+      makeUow({moduleRepo}),
+      makeIdGen(),
+    );
+    await expect(
+      handler.handle(
+        new CreateDataLinkCommand(SRC_MODULE, SRC_PORT, DST_MODULE, DST_PORT),
+      ),
+    ).rejects.toThrow('ownership');
+  });
+});
diff --git a/packages/core/tests/unit/application/usecase-designer/usecase/get-component-with-subsystem/build-subsystem-tree.spec.ts b/packages/core/tests/unit/application/usecase-designer/usecase/get-component-with-subsystem/build-subsystem-tree.spec.ts
index 558f00f0e..ec52b8662 100644
--- a/packages/core/tests/unit/application/usecase-designer/usecase/get-component-with-subsystem/build-subsystem-tree.spec.ts
+++ b/packages/core/tests/unit/application/usecase-designer/usecase/get-component-with-subsystem/build-subsystem-tree.spec.ts
@@ -9,6 +9,7 @@ import type {SpfModuleReadModel} from '../../../../../../src/application/ports/p
 import type {DataLinkReadModel} from '../../../../../../src/application/ports/persistence/query-services/link/data-link-read-model.js';
 import type {ControlLinkReadModel} from '../../../../../../src/application/ports/persistence/query-services/link/control-link-read-model.js';
 import type {SubsystemReadModel} from '../../../../../../src/application/ports/persistence/query-services/subsystem/subsystem-read-model.js';
+import type {SubsystemDataLinkReadModel} from '../../../../../../src/application/ports/persistence/query-services/usecase/query-models/subsystem-data-link-read-model.js';
 import {LINK_TYPE} from '../../../../../../src/domain/entities/usecase-data/links/link-type.js';
 
 // =============================================================================
@@ -95,6 +96,22 @@ function makeControlLink(
   };
 }
 
+function makeSlsSegment(
+  id: number,
+  src: number,
+  dst: number,
+  parentLinkId: number | null = null,
+): SubsystemDataLinkReadModel {
+  return {
+    systemId: id,
+    sourceNodeSystemId: src,
+    destinationNodeSystemId: dst,
+    sourcePortSystemId: BASE_PORT + id,
+    destinationPortSystemId: BASE_PORT + 100 + id,
+    dataLinkSystemId: parentLinkId,
+  };
+}
+
 function makeSub(id: number, parentId?: number): SubsystemReadModel {
   return {
     systemId: id,
@@ -112,49 +129,40 @@ function linkIds(links: Array<{systemId: number}>): number[] {
 // =============================================================================
 // Link constants for the primary topology
 //
-// Raw links come from dataLinkQueryService.findByUsecaseIds — they are always
-// module-to-module.  Virtual segments come from
-// subsystemQueryService.findDataLinkSegmentsByUsecaseIds — boundary-crossing
-// links generate two virtual segment rows; non-boundary links generate one row
-// identical to the raw link (but with both module IDs, so the handler's
-// subsystem-endpoint filter drops it before buildSubsystemTree sees it).
-//
-// buildSubsystemTree receives the combined flat array that the handler assembles:
-//   flat.dataLinks = rawLinks + filteredVirtualSegments
+// Raw links come from dataLinkQueryService.findByUsecaseIds — always module-to-module.
+// SLS segments come from subsystemQueryService.findDataLinkSegmentsByUsecaseIds —
+// typed as SubsystemDataLinkReadModel[], passed to buildSubsystemTree as the 3rd arg.
 //
-// In these unit tests we deliberately pass BOTH the raw boundary-crossing link
-// AND its corresponding virtual segments to buildSubsystemTree so that the tests
-// verify the natural dropping behaviour of the levelNodeIds filter (the tree
-// builder drops boundary-crossing raw links because neither endpoint is visible
-// at any single level).
-//
-// Link ID map:
+// Raw link ID map:
 //   L1_RAW   =  1  m1 → m2     non-boundary raw link at top level
 //   L2_RAW   =  2  m2 → m3     boundary-crossing raw link (m3 inside SS) — should be DROPPED
-//   L2_OUT   =  3  m2 → SS     outside virtual segment for the m2↔m3 cross-boundary link
-//   L3_IN    =  4  SS → m3     inside virtual segment for the m2↔m3 cross-boundary link
-//   L4_RAW   =  5  m3 → m4     non-boundary raw link inside SS — should be PLACED at SS level
-//   L5_OUT   =  6  m4 → SS1    outside virtual segment for the m4↔m5 cross-boundary link
-//   L6_IN    =  7  SS1 → m5    inside virtual segment for the m4↔m5 cross-boundary link
+//   L4_RAW   =  5  m3 → m4     non-boundary raw link inside SS — placed at SS level
+//   L5_RAW   =  9  m4 → m5     boundary-crossing raw into SS1 — should be DROPPED
 //   L7_RAW   =  8  m5 → m6     non-boundary raw link inside SS1
-//   L4_RAW2  =  9  m4 → m5     boundary-crossing raw link (m5 inside SS1) — should be DROPPED
+//
+// SLS segment ID map:
+//   SLS_L2_OUT (3):  m2 → SS   outside SLS segment for the m2↔m3 boundary link — placed at root
+//   SLS_L3_IN  (4):  SS → m3   inside SLS segment for the m2↔m3 boundary link  — placed at SS level
+//   SLS_L5_OUT (6):  m4 → SS1  outside SLS segment for the m4↔m5 boundary link — placed at SS level
+//   SLS_L6_IN  (7):  SS1 → m5  inside SLS segment for the m4↔m5 boundary link  — placed at SS1 level
 // =============================================================================
 const L1_RAW = makeDataLink(1, M1, M2);
 const L2_RAW = makeDataLink(2, M2, M3); // boundary-crossing — dropped by levelNodeIds
-const L2_OUT = makeDataLink(3, M2, SS); // outside virtual segment, placed at root
-const L3_IN = makeDataLink(4, SS, M3); // inside virtual segment, placed at SS level
-const L4_RAW = makeDataLink(5, M3, M4); // non-boundary raw inside SS, placed at SS level
-const L5_OUT = makeDataLink(6, M4, SS1); // outside virtual for SS1, placed at SS level
-const L6_IN = makeDataLink(7, SS1, M5); // inside virtual for SS1, placed at SS1 level
+const L4_RAW = makeDataLink(5, M3, M4); // non-boundary raw inside SS
+const L5_RAW = makeDataLink(9, M4, M5); // boundary-crossing raw into SS1 — dropped
 const L7_RAW = makeDataLink(8, M5, M6); // non-boundary raw inside SS1
-const L4_RAW2 = makeDataLink(9, M4, M5); // boundary-crossing raw into SS1 — dropped
+
+const SLS_L2_OUT = makeSlsSegment(3, M2, SS, L2_RAW.systemId); // outside SLS at root
+const SLS_L3_IN = makeSlsSegment(4, SS, M3, L2_RAW.systemId); // inside SLS at SS level
+const SLS_L5_OUT = makeSlsSegment(6, M4, SS1, L5_RAW.systemId); // outside SLS at SS level
+const SLS_L6_IN = makeSlsSegment(7, SS1, M5, L5_RAW.systemId); // inside SLS at SS1 level
 
 // =============================================================================
 // Scenario A (initial state): m1 → m2 → SS( m3 → m4 )
 //
-// Flat input supplied to buildSubsystemTree — mirrors what the handler assembles
-// after combining raw links (Pass 2a) with filtered virtual segments (Pass 2b).
-// L2_RAW is included intentionally to verify it is dropped at every level.
+// flat.dataLinks contains only raw mod-mod links.
+// SLS segments are passed separately as the 3rd argument.
+// L2_RAW is included to verify it is dropped at every level by levelNodeIds.
 // =============================================================================
 const INITIAL_FLAT = {
   modules: [
@@ -164,24 +172,18 @@ const INITIAL_FLAT = {
     makeModule(M4, SS), // parentId = SS        → inside SS
   ],
   dataLinks: [
-    L1_RAW, // m1→m2  — non-boundary top-level
+    L1_RAW, // m1→m2  — non-boundary top-level raw link
     L2_RAW, // m2→m3  — boundary-crossing raw (expected to be dropped by levelNodeIds)
-    L2_OUT, // m2→SS  — outside virtual segment (expected at root level)
-    L3_IN, // SS→m3  — inside virtual segment  (expected at SS level)
-    L4_RAW, // m3→m4  — non-boundary raw inside SS (expected at SS level)
+    L4_RAW, // m3→m4  — non-boundary raw inside SS
   ],
   controlLinks: [],
 };
 
 const INITIAL_SUBSYSTEMS = [makeSub(SS)]; // SS is a root subsystem (no parent)
+const INITIAL_SLS = [SLS_L2_OUT, SLS_L3_IN]; // SLS segments for the m2↔m3 boundary
 
 // =============================================================================
 // Scenario B (after adding SS1): m1 → m2 → SS( m3 → m4 → SS1( m5 → m6 ) )
-//
-// The handler has applied the edit-session overlay so findAll returns [SS, SS1]
-// and the virtual segment service returns segments covering SS1's boundary.
-// L4_RAW2 (m4→m5 raw) is included to verify it is dropped — the virtual
-// segments L5_OUT / L6_IN are what represent that connection in the tree.
 // =============================================================================
 const SS1_ADDED_FLAT = {
   modules: [
@@ -189,18 +191,14 @@ const SS1_ADDED_FLAT = {
     makeModule(M2),
     makeModule(M3, SS),
     makeModule(M4, SS),
-    makeModule(M5, SS1), // new module inside SS1
-    makeModule(M6, SS1), // new module inside SS1
+    makeModule(M5, SS1),
+    makeModule(M6, SS1),
   ],
   dataLinks: [
     L1_RAW, // m1→m2     non-boundary top-level
     L2_RAW, // m2→m3     boundary-crossing raw (dropped)
-    L2_OUT, // m2→SS     outside virtual (root level)
-    L3_IN, // SS→m3     inside virtual (SS level)
     L4_RAW, // m3→m4     non-boundary raw inside SS
-    L4_RAW2, // m4→m5     boundary-crossing raw into SS1 (dropped)
-    L5_OUT, // m4→SS1    outside virtual for SS1 (SS level)
-    L6_IN, // SS1→m5    inside virtual for SS1 (SS1 level)
+    L5_RAW, // m4→m5     boundary-crossing raw into SS1 (dropped)
     L7_RAW, // m5→m6     non-boundary raw inside SS1
   ],
   controlLinks: [],
@@ -210,6 +208,12 @@ const SS1_ADDED_SUBSYSTEMS = [
   makeSub(SS), // root subsystem, unchanged
   makeSub(SS1, SS), // new subsystem nested inside SS
 ];
+const SS1_ADDED_SLS = [
+  SLS_L2_OUT, // outside SLS at root (m2→SS)
+  SLS_L3_IN, // inside SLS at SS level (SS→m3)
+  SLS_L5_OUT, // outside SLS at SS level (m4→SS1)
+  SLS_L6_IN, // inside SLS at SS1 level (SS1→m5)
+];
 
 // =============================================================================
 // Tests
@@ -218,32 +222,23 @@ const SS1_ADDED_SUBSYSTEMS = [
 describe('buildSubsystemTree', () => {
   // ---------------------------------------------------------------------------
   // Scenario 1 — No subsystems: all modules and links stay at the root level
-  //
-  // When subsystems = [], buildSubsystemTree has no children to recurse into.
-  // Every module is a top-level module (parentId = undefined) and every link
-  // has both endpoints visible at the root level, so nothing is dropped and
-  // the result is a flat root-only structure.
   // ---------------------------------------------------------------------------
   describe('Scenario 1 — no subsystems: all content stays at root', () => {
     it('returns all modules at root and no subsystem nodes', () => {
       const result = buildSubsystemTree(
         {
           modules: [makeModule(M1), makeModule(M2)],
-          dataLinks: [L1_RAW], // m1→m2 non-boundary, both top-level
+          dataLinks: [L1_RAW],
           controlLinks: [],
         },
         [], // no subsystems in the file
+        [], // no SLS segments
       );
 
-      // All modules land at root because parentId = undefined
       expect(result.modules.map(m => m.systemId)).toEqual([M1, M2]);
-
-      // The m1→m2 link is placed at root — both endpoints are top-level modules
-      // (category 1 of levelNodeIds) so the filter passes it through
       expect(linkIds(result.dataLinks)).toEqual([L1_RAW.systemId]);
-
-      // No subsystem nodes generated
       expect(result.subsystems).toHaveLength(0);
+      expect(result.subsystemDataLinks).toHaveLength(0);
     });
   });
 
@@ -252,52 +247,50 @@ describe('buildSubsystemTree', () => {
   //
   // Key things being verified:
   //
-  //   a) Module placement: m1/m2 at root (parentId=undefined),
-  //      m3/m4 at SS level (parentId=SS).
+  //   a) Module placement: m1/m2 at root, m3/m4 at SS level.
   //
-  //   b) Non-boundary raw link (L1_RAW: m1→m2) is placed at root level — both
-  //      endpoints are top-level modules (category 1 of levelNodeIds at root).
+  //   b) Non-boundary raw link (L1_RAW: m1→m2) is placed at root level dataLinks.
   //
-  //   c) Boundary-crossing raw link (L2_RAW: m2→m3) is DROPPED from the output
-  //      entirely — at root level m3 is not visible, and at SS level m2 is not
-  //      visible. The levelNodeIds predicate rejects it at both levels.
+  //   c) Boundary-crossing raw link (L2_RAW: m2→m3) is DROPPED entirely —
+  //      at root level m3 is not visible, and at SS level m2 is not visible.
   //
-  //   d) Outside virtual segment (L2_OUT: m2→SS) is placed at root — m2 is a
-  //      direct module child (category 1) and SS is a direct child subsystem
+  //   d) Outside SLS segment (SLS_L2_OUT: m2→SS) is placed at root subsystemDataLinks —
+  //      m2 is a direct module child (category 1) and SS is a direct child subsystem
   //      (category 2) at the root level.
   //
-  //   e) Inside virtual segment (L3_IN: SS→m3) is placed at SS level — SS is
-  //      the subsystem's own ID (category 3) and m3 is a direct module child
+  //   e) Inside SLS segment (SLS_L3_IN: SS→m3) is placed at SS subsystemDataLinks —
+  //      SS is the subsystem's own ID (category 3) and m3 is a direct module child
   //      (category 1) at the SS level.
   //
-  //   f) Non-boundary raw link (L4_RAW: m3→m4) is placed at SS level — both
-  //      m3 and m4 are direct module children of SS (category 1 at SS level).
+  //   f) Non-boundary raw link (L4_RAW: m3→m4) is placed at SS level dataLinks —
+  //      both m3 and m4 are direct module children of SS (category 1).
   // ---------------------------------------------------------------------------
   describe('Scenario 2 — initial state: SS containing m3 and m4', () => {
     let result: ReturnType<typeof buildSubsystemTree>;
 
     beforeAll(() => {
-      result = buildSubsystemTree(INITIAL_FLAT, INITIAL_SUBSYSTEMS);
+      result = buildSubsystemTree(
+        INITIAL_FLAT,
+        INITIAL_SUBSYSTEMS,
+        INITIAL_SLS,
+      );
     });
 
     it('places m1 and m2 at the root level (parentId = undefined)', () => {
       expect(result.modules.map(m => m.systemId).sort()).toEqual([M1, M2]);
     });
 
-    it('places the non-boundary raw link L1_RAW (m1→m2) at root level', () => {
+    it('places the non-boundary raw link L1_RAW (m1→m2) at root dataLinks', () => {
       expect(linkIds(result.dataLinks)).toContain(L1_RAW.systemId);
     });
 
-    it('places the outside virtual segment L2_OUT (m2→SS) at root level', () => {
-      // L2_OUT has src=M2 (cat-1: direct module child) and dst=SS (cat-2: direct
-      // child subsystem), so both endpoints are in root-level levelNodeIds.
-      expect(linkIds(result.dataLinks)).toContain(L2_OUT.systemId);
+    it('places the outside SLS segment SLS_L2_OUT (m2→SS) at root subsystemDataLinks', () => {
+      expect(result.subsystemDataLinks.map(s => s.systemId)).toContain(
+        SLS_L2_OUT.systemId,
+      );
     });
 
-    it('drops the boundary-crossing raw link L2_RAW (m2→m3) from root level', () => {
-      // m3 is inside SS — its systemId is not in root-level levelNodeIds.
-      // The levelNodeIds filter rejects the link at root (m3 not visible) and at
-      // SS level (m2 not visible), so it does not appear in any output level.
+    it('drops the boundary-crossing raw link L2_RAW (m2→m3) from root dataLinks', () => {
       expect(linkIds(result.dataLinks)).not.toContain(L2_RAW.systemId);
     });
 
@@ -311,21 +304,19 @@ describe('buildSubsystemTree', () => {
       expect(ssChildren.modules.map(m => m.systemId).sort()).toEqual([M3, M4]);
     });
 
-    it('places the inside virtual segment L3_IN (SS→m3) at SS level', () => {
-      // SS.systemId = category 3 (this subsystem's own ID) and m3 = category 1
-      // (direct module child) in the SS-level levelNodeIds set.
+    it('places the inside SLS segment SLS_L3_IN (SS→m3) at SS subsystemDataLinks', () => {
       const ssChildren = result.subsystems[0].children;
-      expect(linkIds(ssChildren.dataLinks)).toContain(L3_IN.systemId);
+      expect(ssChildren.subsystemDataLinks.map(s => s.systemId)).toContain(
+        SLS_L3_IN.systemId,
+      );
     });
 
-    it('places the non-boundary raw link L4_RAW (m3→m4) at SS level', () => {
-      // Both m3 and m4 are direct module children of SS (category 1 at SS level).
+    it('places the non-boundary raw link L4_RAW (m3→m4) at SS dataLinks', () => {
       const ssChildren = result.subsystems[0].children;
       expect(linkIds(ssChildren.dataLinks)).toContain(L4_RAW.systemId);
     });
 
-    it('drops the boundary-crossing raw link L2_RAW (m2→m3) from SS level', () => {
-      // m2 is not inside SS, so it is not in the SS-level levelNodeIds set.
+    it('drops the boundary-crossing raw link L2_RAW (m2→m3) from SS dataLinks', () => {
       const ssChildren = result.subsystems[0].children;
       expect(linkIds(ssChildren.dataLinks)).not.toContain(L2_RAW.systemId);
     });
@@ -338,52 +329,48 @@ describe('buildSubsystemTree', () => {
   // ---------------------------------------------------------------------------
   // Scenario 3 — Edit session adds SS1: m1 → m2 → SS( m3 → m4 → SS1( m5 → m6 ) )
   //
-  // After the edit session overlay runs, the handler assembles:
-  //   - findAll() returns [SS, SS1(parentId=SS)]
-  //   - findByUsecaseIds (modules) returns m1..m6
-  //   - virtual segment service returns segments for BOTH boundaries (m2→SS and m4→SS1)
-  //
   // Key things being verified:
   //
-  //   a) SS1 appears nested inside SS in the tree — buildSubsystemTree recurses
-  //      into SS and finds SS1 as a direct child of SS (parentId=SS).
+  //   a) SS1 appears nested inside SS in the tree.
   //
   //   b) m5 and m6 are placed inside SS1 (parentId = SS1).
   //
-  //   c) Outside virtual segment for SS1 (L5_OUT: m4→SS1) is placed at SS level —
-  //      m4 is a direct module child of SS (category 1) and SS1 is a direct child
-  //      subsystem of SS (category 2) at the SS level.
+  //   c) Outside SLS segment for SS1 (SLS_L5_OUT: m4→SS1) is placed at SS
+  //      subsystemDataLinks — m4 is category 1 and SS1 is category 2 at SS level.
   //
-  //   d) Inside virtual segment for SS1 (L6_IN: SS1→m5) is placed at SS1 level —
-  //      SS1 is the subsystem's own ID (category 3) and m5 is a direct module child
-  //      (category 1) at the SS1 level.
+  //   d) Inside SLS segment for SS1 (SLS_L6_IN: SS1→m5) is placed at SS1
+  //      subsystemDataLinks — SS1 is category 3 and m5 is category 1 at SS1 level.
   //
-  //   e) Non-boundary raw link L7_RAW (m5→m6) is placed at SS1 level — both
-  //      m5 and m6 are direct module children of SS1 (category 1).
+  //   e) Non-boundary raw link L7_RAW (m5→m6) is placed at SS1 dataLinks.
   //
-  //   f) Boundary-crossing raw link L4_RAW2 (m4→m5) is DROPPED — at SS level
-  //      m5 is not visible (m5 is inside SS1, not a direct child of SS), and at
-  //      SS1 level m4 is not visible.  The virtual pair L5_OUT/L6_IN represents
-  //      this connection at the correct levels instead.
+  //   f) Boundary-crossing raw link L5_RAW (m4→m5) is DROPPED — m5 is inside
+  //      SS1 (not a direct child of SS) so it is never in any level's levelNodeIds.
   //
-  //   g) All original links from scenario 2 remain at their correct levels
-  //      (the new subsystem does not disturb existing placements).
+  //   g) All original links from scenario 2 remain at their correct levels.
   // ---------------------------------------------------------------------------
   describe('Scenario 3 — edit session adds SS1 nested inside SS', () => {
     let result: ReturnType<typeof buildSubsystemTree>;
 
     beforeAll(() => {
-      result = buildSubsystemTree(SS1_ADDED_FLAT, SS1_ADDED_SUBSYSTEMS);
+      result = buildSubsystemTree(
+        SS1_ADDED_FLAT,
+        SS1_ADDED_SUBSYSTEMS,
+        SS1_ADDED_SLS,
+      );
     });
 
     it('root still contains only m1 and m2', () => {
       expect(result.modules.map(m => m.systemId).sort()).toEqual([M1, M2]);
     });
 
-    it('root dataLinks still contains L1_RAW and L2_OUT, nothing new', () => {
-      expect(linkIds(result.dataLinks)).toEqual(
-        [L1_RAW.systemId, L2_OUT.systemId].sort((a, b) => a - b),
-      );
+    it('root dataLinks still contains only L1_RAW (no SLS at root changes)', () => {
+      expect(linkIds(result.dataLinks)).toEqual([L1_RAW.systemId]);
+    });
+
+    it('root subsystemDataLinks contains SLS_L2_OUT only', () => {
+      expect(result.subsystemDataLinks.map(s => s.systemId)).toEqual([
+        SLS_L2_OUT.systemId,
+      ]);
     });
 
     it('SS still contains only m3 and m4 as direct modules', () => {
@@ -391,25 +378,22 @@ describe('buildSubsystemTree', () => {
       expect(ss.children.modules.map(m => m.systemId).sort()).toEqual([M3, M4]);
     });
 
-    it('places the outside virtual segment L5_OUT (m4→SS1) at SS level', () => {
-      // m4 is a direct module child of SS (category 1) and SS1 is a direct
-      // child subsystem of SS (category 2) — both visible at the SS level.
+    it('places the outside SLS segment SLS_L5_OUT (m4→SS1) at SS subsystemDataLinks', () => {
       const ss = result.subsystems.find(s => s.systemId === SS)!;
-      expect(linkIds(ss.children.dataLinks)).toContain(L5_OUT.systemId);
+      expect(ss.children.subsystemDataLinks.map(s => s.systemId)).toContain(
+        SLS_L5_OUT.systemId,
+      );
     });
 
-    it('drops the boundary-crossing raw link L4_RAW2 (m4→m5) at SS level', () => {
-      // m5 is inside SS1, not a direct child of SS — not in SS-level levelNodeIds.
-      // The levelNodeIds filter drops L4_RAW2 here; L5_OUT/L6_IN take its place.
+    it('drops the boundary-crossing raw link L5_RAW (m4→m5) at SS dataLinks', () => {
       const ss = result.subsystems.find(s => s.systemId === SS)!;
-      expect(linkIds(ss.children.dataLinks)).not.toContain(L4_RAW2.systemId);
+      expect(linkIds(ss.children.dataLinks)).not.toContain(L5_RAW.systemId);
     });
 
-    it('drops the boundary-crossing raw link L4_RAW2 (m4→m5) at SS1 level too', () => {
-      // m4 is not inside SS1, so it is not in SS1-level levelNodeIds either.
+    it('drops the boundary-crossing raw link L5_RAW (m4→m5) at SS1 dataLinks too', () => {
       const ss = result.subsystems.find(s => s.systemId === SS)!;
       const ss1 = ss.children.subsystems.find(s => s.systemId === SS1)!;
-      expect(linkIds(ss1.children.dataLinks)).not.toContain(L4_RAW2.systemId);
+      expect(linkIds(ss1.children.dataLinks)).not.toContain(L5_RAW.systemId);
     });
 
     it('SS has exactly one child subsystem: SS1', () => {
@@ -427,16 +411,15 @@ describe('buildSubsystemTree', () => {
       ]);
     });
 
-    it('places the inside virtual segment L6_IN (SS1→m5) at SS1 level', () => {
-      // SS1.systemId = category 3 (this subsystem's own boundary ID) and
-      // m5 = category 1 (direct module child) in SS1-level levelNodeIds.
+    it('places the inside SLS segment SLS_L6_IN (SS1→m5) at SS1 subsystemDataLinks', () => {
       const ss = result.subsystems.find(s => s.systemId === SS)!;
       const ss1 = ss.children.subsystems[0];
-      expect(linkIds(ss1.children.dataLinks)).toContain(L6_IN.systemId);
+      expect(ss1.children.subsystemDataLinks.map(s => s.systemId)).toContain(
+        SLS_L6_IN.systemId,
+      );
     });
 
-    it('places the non-boundary raw link L7_RAW (m5→m6) at SS1 level', () => {
-      // Both m5 and m6 are direct module children of SS1 (category 1 at SS1 level).
+    it('places the non-boundary raw link L7_RAW (m5→m6) at SS1 dataLinks', () => {
       const ss = result.subsystems.find(s => s.systemId === SS)!;
       const ss1 = ss.children.subsystems[0];
       expect(linkIds(ss1.children.dataLinks)).toContain(L7_RAW.systemId);
@@ -452,60 +435,47 @@ describe('buildSubsystemTree', () => {
   // ---------------------------------------------------------------------------
   // Scenario 4 — Edit session deletes SS1: tree reverts to SS( m3, m4 ) only
   //
-  // After the edit session overlay removes SS1, the handler assembles:
-  //   - findAll() returns only [SS] — SS1 has been removed by overlay
-  //   - modules returns only [m1..m4] — m5 and m6 have also been removed
-  //   - virtual segments contain no SS1 boundary rows
-  //
-  // In this test we model the "modules deleted from scope" path by passing
-  // SS1 in the subsystems list but with NO modules inside it.
-  // This exercises the pruning rule (QWS-08): a subsystem with no in-scope
-  // module at or beneath it is omitted from the output tree entirely.
-  //
-  // Key things being verified:
-  //
-  //   a) SS1 is present in the subsystems input but is PRUNED because
-  //      hasInScopeDescendant(SS1) returns false (no module has parentId = SS1).
-  //
-  //   b) SS still appears and contains m3/m4 exactly as in the initial state.
-  //
-  //   c) No SS1 boundary virtual segments (L5_OUT, L6_IN) are in the flat input,
-  //      so SS-level dataLinks contain only L3_IN and L4_RAW (initial state).
+  // SS1 is present in the subsystems input but is PRUNED because
+  // hasInScopeDescendant(SS1) returns false (no module has parentId = SS1).
   // ---------------------------------------------------------------------------
   describe('Scenario 4 — edit session deletes SS1: pruning removes it from tree', () => {
     it('prunes SS1 when no in-scope module lives inside it', () => {
-      // SS1 is still listed in the subsystem definitions but the overlay has
-      // removed all its modules — modules[] contains only m1..m4.
-      const result = buildSubsystemTree(INITIAL_FLAT, [
-        makeSub(SS),
-        makeSub(SS1, SS), // SS1 present in file definitions but has no in-scope modules
-      ]);
+      const result = buildSubsystemTree(
+        INITIAL_FLAT,
+        [
+          makeSub(SS),
+          makeSub(SS1, SS), // SS1 present in file definitions but has no in-scope modules
+        ],
+        INITIAL_SLS,
+      );
 
-      // SS1 must not appear anywhere in the output
       const ss = result.subsystems.find(s => s.systemId === SS)!;
       expect(ss.children.subsystems).toHaveLength(0); // SS1 was pruned
     });
 
     it('SS still contains m3 and m4 after SS1 is pruned', () => {
-      const result = buildSubsystemTree(INITIAL_FLAT, [
-        makeSub(SS),
-        makeSub(SS1, SS),
-      ]);
+      const result = buildSubsystemTree(
+        INITIAL_FLAT,
+        [makeSub(SS), makeSub(SS1, SS)],
+        INITIAL_SLS,
+      );
 
       const ss = result.subsystems.find(s => s.systemId === SS)!;
       expect(ss.children.modules.map(m => m.systemId).sort()).toEqual([M3, M4]);
     });
 
-    it('SS-level dataLinks are unchanged after SS1 is pruned', () => {
-      const result = buildSubsystemTree(INITIAL_FLAT, [
-        makeSub(SS),
-        makeSub(SS1, SS),
-      ]);
+    it('SS-level dataLinks and subsystemDataLinks are unchanged after SS1 is pruned', () => {
+      const result = buildSubsystemTree(
+        INITIAL_FLAT,
+        [makeSub(SS), makeSub(SS1, SS)],
+        INITIAL_SLS,
+      );
 
       const ss = result.subsystems.find(s => s.systemId === SS)!;
-      expect(linkIds(ss.children.dataLinks)).toEqual(
-        [L3_IN.systemId, L4_RAW.systemId].sort((a, b) => a - b),
-      );
+      expect(linkIds(ss.children.dataLinks)).toEqual([L4_RAW.systemId]);
+      expect(ss.children.subsystemDataLinks.map(s => s.systemId)).toEqual([
+        SLS_L3_IN.systemId,
+      ]);
     });
   });
 
@@ -514,27 +484,13 @@ describe('buildSubsystemTree', () => {
   //
   // SS_A has no direct modules of its own but has an in-scope module (M_DEEP)
   // nested two levels deep inside SS_B.  The pruning predicate must recursively
-  // descend into SS_B to find M_DEEP and keep SS_A in the output even though
-  // SS_A.modules = [].
-  //
-  // Per QWS-08: "Ancestor subsystems that are purely on the path to in-scope
-  // modules appear with modules: [] and empty links."
-  //
-  // Key things being verified:
-  //
-  //   a) hasInScopeDescendant(SS_A) recurses into SS_B, finds M_DEEP →
-  //      returns true → SS_A is NOT pruned.
-  //
-  //   b) SS_A appears in the output but with modules = [] and dataLinks = []
-  //      (it has no direct children of its own).
-  //
-  //   c) SS_B appears nested inside SS_A with M_DEEP as its only module.
+  // descend into SS_B to find M_DEEP and keep SS_A in the output.
   // ---------------------------------------------------------------------------
   describe('Scenario 5 — structural ancestor: SS_A contains SS_B which contains a module', () => {
     it('keeps SS_A despite having no direct modules', () => {
       const result = buildSubsystemTree(
         {
-          modules: [makeModule(M_DEEP, SS_B)], // only module is 2 levels deep
+          modules: [makeModule(M_DEEP, SS_B)],
           dataLinks: [],
           controlLinks: [],
         },
@@ -542,27 +498,31 @@ describe('buildSubsystemTree', () => {
           makeSub(SS_A), // root subsystem — no direct modules
           makeSub(SS_B, SS_A), // child of SS_A — has M_DEEP directly inside it
         ],
+        [], // no SLS segments
       );
 
       expect(result.subsystems).toHaveLength(1);
       expect(result.subsystems[0].systemId).toBe(SS_A);
     });
 
-    it('SS_A has empty modules and dataLinks arrays at its own level', () => {
+    it('SS_A has empty modules, dataLinks, and subsystemDataLinks at its own level', () => {
       const result = buildSubsystemTree(
         {modules: [makeModule(M_DEEP, SS_B)], dataLinks: [], controlLinks: []},
         [makeSub(SS_A), makeSub(SS_B, SS_A)],
+        [],
       );
 
       const ssA = result.subsystems[0];
       expect(ssA.children.modules).toHaveLength(0);
       expect(ssA.children.dataLinks).toHaveLength(0);
+      expect(ssA.children.subsystemDataLinks).toHaveLength(0);
     });
 
     it('SS_B is nested inside SS_A and contains M_DEEP', () => {
       const result = buildSubsystemTree(
         {modules: [makeModule(M_DEEP, SS_B)], dataLinks: [], controlLinks: []},
         [makeSub(SS_A), makeSub(SS_B, SS_A)],
+        [],
       );
 
       const ssA = result.subsystems[0];
@@ -576,12 +536,14 @@ describe('buildSubsystemTree', () => {
   // ---------------------------------------------------------------------------
   // Scenario 6 — Control links follow the same levelNodeIds placement rule
   //
-  // The same 3-category levelNodeIds set that routes data links also routes
-  // control links.  This scenario verifies:
-  //   CL_RAW  (m1↔m2, top-level) → placed at root
-  //   CL_RAW2 (m3↔m4, inside SS) → placed at SS level
-  //   CL_OUT  (m2↔SS, outside virtual) → placed at root
-  //   CL_IN   (SS↔m3, inside virtual) → placed at SS level
+  // The same 3-category levelNodeIds set that routes data links and SLS also
+  // routes control links.  Virtual control link segments (boundary-crossing)
+  // are still merged into flat.controlLinks by the handler (control link SLS
+  // refactor is out of scope).
+  //   CL_RAW  (m1↔m2, top-level) → placed at root controlLinks
+  //   CL_RAW2 (m3↔m4, inside SS) → placed at SS controlLinks
+  //   CL_OUT  (m2↔SS, outside virtual) → placed at root controlLinks
+  //   CL_IN   (SS↔m3, inside virtual) → placed at SS controlLinks
   //   CL_BC   (m2↔m3, boundary-crossing raw) → dropped at every level
   // ---------------------------------------------------------------------------
   describe('Scenario 6 — control links obey the same levelNodeIds rule as data links', () => {
@@ -604,6 +566,7 @@ describe('buildSubsystemTree', () => {
           controlLinks: [CL_RAW, CL_BC, CL_OUT, CL_IN, CL_RAW2],
         },
         [makeSub(SS)],
+        [], // no SLS segments
       );
 
       // Root: CL_RAW (m1↔m2 both cat-1) and CL_OUT (m2=cat-1, SS=cat-2)
diff --git a/packages/core/tests/unit/application/usecase-designer/usecase/get-component-with-subsystem/get-components-with-subsystems.handler.spec.ts b/packages/core/tests/unit/application/usecase-designer/usecase/get-component-with-subsystem/get-components-with-subsystems.handler.spec.ts
index e4173a424..e8480e52e 100644
--- a/packages/core/tests/unit/application/usecase-designer/usecase/get-component-with-subsystem/get-components-with-subsystems.handler.spec.ts
+++ b/packages/core/tests/unit/application/usecase-designer/usecase/get-component-with-subsystem/get-components-with-subsystems.handler.spec.ts
@@ -12,6 +12,7 @@ import type {SpfModuleReadModel} from '../../../../../../src/application/ports/p
 import type {DataLinkReadModel} from '../../../../../../src/application/ports/persistence/query-services/link/data-link-read-model.js';
 import type {ControlLinkReadModel} from '../../../../../../src/application/ports/persistence/query-services/link/control-link-read-model.js';
 import type {SubsystemReadModel} from '../../../../../../src/application/ports/persistence/query-services/subsystem/subsystem-read-model.js';
+import type {SubsystemDataLinkReadModel} from '../../../../../../src/application/ports/persistence/query-services/usecase/query-models/subsystem-data-link-read-model.js';
 import {UseCaseReadModel} from '../../../../../../src/application/ports/persistence/query-services/usecase/query-models/usecase-read-model.js';
 import {
   Result,
@@ -20,8 +21,7 @@ import {
 import {LINK_TYPE} from '../../../../../../src/domain/entities/usecase-data/links/link-type.js';
 
 // =============================================================================
-// Fixed IDs — mirrors the build-subsystem-tree.spec.ts topology so that the
-// two test files tell the same story end-to-end.
+// Fixed IDs — mirrors the build-subsystem-tree.spec.ts topology.
 //
 // Topology across all scenarios:
 //
@@ -100,6 +100,22 @@ function makeControlLink(
   };
 }
 
+function makeSlsSegment(
+  id: number,
+  src: number,
+  dst: number,
+  parentLinkId: number | null = null,
+): SubsystemDataLinkReadModel {
+  return {
+    systemId: id,
+    sourceNodeSystemId: src,
+    destinationNodeSystemId: dst,
+    sourcePortSystemId: BASE_PORT + id,
+    destinationPortSystemId: BASE_PORT + 100 + id,
+    dataLinkSystemId: parentLinkId,
+  };
+}
+
 function makeSub(id: number, parentId?: number): SubsystemReadModel {
   return {
     systemId: id,
@@ -112,49 +128,37 @@ function makeSub(id: number, parentId?: number): SubsystemReadModel {
 // =============================================================================
 // Link constants — same logical link set as build-subsystem-tree.spec.ts
 //
-// Raw links (from dataLinkQueryService.findByUsecaseIds):
+// Raw links (from dataLinkQueryService.findByUsecaseIds) — mod-mod only:
 //   L1_RAW  (1):  m1→m2   non-boundary, top-level
 //   L2_RAW  (2):  m2→m3   boundary-crossing raw — DROPPED by buildSubsystemTree
-//   L4_RAW  (5):  m3→m4   non-boundary raw inside SS — placed at SS level
-//   L4_RAW2 (9):  m4→m5   boundary-crossing raw into SS1 — DROPPED
-//   L7_RAW  (8):  m5→m6   non-boundary raw inside SS1 — placed at SS1 level
+//   L4_RAW  (5):  m3→m4   non-boundary raw inside SS — placed at SS dataLinks
+//   L5_RAW  (9):  m4→m5   boundary-crossing raw into SS1 — DROPPED
+//   L7_RAW  (8):  m5→m6   non-boundary raw inside SS1 — placed at SS1 dataLinks
 //
-// Virtual segments (from subsystemQueryService.findDataLinkSegmentsByUsecaseIds):
-//   L2_OUT  (3):  m2→SS   outside virtual — passes handler filter (SS is a subsystem)
-//   L3_IN   (4):  SS→m3   inside virtual  — passes handler filter (SS is a subsystem)
-//   L4_VIRT (20): m3→m4   non-boundary virtual — FILTERED OUT by handler (no subsystem endpoint)
-//   L5_OUT  (6):  m4→SS1  outside virtual for SS1 — passes handler filter (SS1 is a subsystem)
-//   L6_IN   (7):  SS1→m5  inside virtual for SS1  — passes handler filter (SS1 is a subsystem)
-//   L7_VIRT (21): m5→m6   non-boundary virtual — FILTERED OUT by handler (no subsystem endpoint)
-//
-// The two-layer filtering is:
-//   1. Handler layer: drops virtual segments whose both endpoints are module IDs
-//      (the subsystem-endpoint filter: subsystemIds.has(src) || subsystemIds.has(dst))
-//   2. buildSubsystemTree layer: drops boundary-crossing raw links whose endpoints
-//      are never both visible in the same levelNodeIds set
+// SLS segments (from subsystemQueryService.findDataLinkSegmentsByUsecaseIds):
+//   SLS_L2_OUT (3):  m2→SS   outside SLS — placed at root subsystemDataLinks
+//   SLS_L3_IN  (4):  SS→m3   inside SLS  — placed at SS subsystemDataLinks
+//   SLS_L5_OUT (6):  m4→SS1  outside SLS for SS1 — placed at SS subsystemDataLinks
+//   SLS_L6_IN  (7):  SS1→m5  inside SLS for SS1  — placed at SS1 subsystemDataLinks
 // =============================================================================
 const L1_RAW = makeDataLink(1, M1, M2);
 const L2_RAW = makeDataLink(2, M2, M3); // boundary-crossing raw — dropped by tree builder
-const L2_OUT = makeDataLink(3, M2, SS); // outside virtual — passes handler filter
-const L3_IN = makeDataLink(4, SS, M3); // inside virtual  — passes handler filter
 const L4_RAW = makeDataLink(5, M3, M4); // non-boundary raw inside SS
-const L5_OUT = makeDataLink(6, M4, SS1); // outside virtual for SS1
-const L6_IN = makeDataLink(7, SS1, M5); // inside virtual for SS1
+const L5_RAW = makeDataLink(9, M4, M5); // boundary-crossing raw into SS1 — dropped
 const L7_RAW = makeDataLink(8, M5, M6); // non-boundary raw inside SS1
-const L4_RAW2 = makeDataLink(9, M4, M5); // boundary-crossing raw into SS1 — dropped
-const L4_VIRT = makeDataLink(20, M3, M4); // non-boundary virtual — filtered by handler
-const L7_VIRT = makeDataLink(21, M5, M6); // non-boundary virtual — filtered by handler
+
+const SLS_L2_OUT = makeSlsSegment(3, M2, SS, L2_RAW.systemId); // outside SLS at root
+const SLS_L3_IN = makeSlsSegment(4, SS, M3, L2_RAW.systemId); // inside SLS at SS level
+const SLS_L5_OUT = makeSlsSegment(6, M4, SS1, L5_RAW.systemId); // outside SLS at SS
+const SLS_L6_IN = makeSlsSegment(7, SS1, M5, L5_RAW.systemId); // inside SLS at SS1
 
 // =============================================================================
 // QueryServices factory
 //
 // Every method is a jest.fn() so tests can assert call/no-call behaviour.
-// Defaults represent the happy-path initial state (SS only, m1..m4, no SS1).
-// Override individual properties for deviation scenarios.
-//
-// The subsystemQueryService stub deliberately includes a non-boundary virtual
-// segment (L4_VIRT) in findDataLinkSegmentsByUsecaseIds so that H3 can assert
-// the handler filters it out before passing the flat model to buildSubsystemTree.
+// Defaults represent the happy-path initial state (SS only, m1..m4).
+// virtualDataLinks is now SubsystemDataLinkReadModel[] — only true SLS segments,
+// no non-boundary rows.  Override individual properties for deviation scenarios.
 // =============================================================================
 type ServiceOverrides = {
   fileId?: number;
@@ -163,7 +167,7 @@ type ServiceOverrides = {
   subsystems?: SubsystemReadModel[];
   rawDataLinks?: DataLinkReadModel[];
   rawControlLinks?: ControlLinkReadModel[];
-  virtualDataLinks?: DataLinkReadModel[];
+  virtualDataLinks?: SubsystemDataLinkReadModel[];
   virtualControlLinks?: ControlLinkReadModel[];
 };
 
@@ -180,7 +184,7 @@ function makeServices(overrides: ServiceOverrides = {}): QueryServices {
     subsystems = [makeSub(SS)],
     rawDataLinks = [L1_RAW, L2_RAW, L4_RAW],
     rawControlLinks = [],
-    virtualDataLinks = [L2_OUT, L3_IN, L4_VIRT],
+    virtualDataLinks = [SLS_L2_OUT, SLS_L3_IN],
     virtualControlLinks = [],
   } = overrides;
 
@@ -223,7 +227,7 @@ function makeQuery(
   );
 }
 
-/** Extracts all dataLink systemIds from a tree node (flat helper for assertions). */
+/** Extracts all dataLink systemIds from a tree node. */
 function collectDataLinkIds(node: {
   dataLinks: Array<{systemId: string | number}>;
 }): number[] {
@@ -237,21 +241,9 @@ function collectDataLinkIds(node: {
 describe('GetComponentsWithSubsystemsHandler', () => {
   // ---------------------------------------------------------------------------
   // Scenario H1 — Invalid usecase ID throws Error
-  //
-  // The handler validates every requested systemId against the full usecase list
-  // returned by getAllUseCases (which applies overlay, so session-created usecases
-  // are included).  If any ID is not found, the handler throws an Error before
-  // loading modules or links.  The controller calls toApiResult() which requires
-  // handlers to throw on failure, never return Result.fail() — returning
-  // Result.fail would produce a generic 500 from toApiResult's contract guard.
-  //
-  // Key things being verified:
-  //   a) Handler throws when an unknown ID is in the request.
-  //   b) Module and link query services are NOT called (fail-fast gate).
   // ---------------------------------------------------------------------------
   describe('Scenario H1 — invalid usecase ID: handler throws', () => {
     it('throws when a requested systemId is not in getAllUseCases', async () => {
-      // getAllUseCases returns only UC=1; the query asks for 999 which is unknown.
       const services = makeServices({usecases: [new UseCaseReadModel(UC, [])]});
       const handler = new GetComponentsWithSubsystemsHandler(services);
 
@@ -264,7 +256,6 @@ describe('GetComponentsWithSubsystemsHandler', () => {
 
       await expect(handler.handle(makeQuery([999]))).rejects.toThrow();
 
-      // The handler short-circuits at the validation gate — no expensive queries
       expect(
         services.spfModuleQueryService.findByUsecaseIds,
       ).not.toHaveBeenCalled();
@@ -278,22 +269,12 @@ describe('GetComponentsWithSubsystemsHandler', () => {
   // Scenario H2 — No subsystems: handler uses raw links only (QWS-04 fallback)
   //
   // When findAll() returns an empty array the handler skips virtual segment
-  // loading entirely — virtual segment tables have no rows when there is no
-  // subsystem context in the file.
-  //
-  // Key things being verified:
-  //   a) dataLinkQueryService.findByUsecaseIds IS called (raw links always loaded).
-  //   b) subsystemQueryService.findDataLinkSegmentsByUsecaseIds is NOT called.
-  //   c) subsystemQueryService.findControlLinkSegmentsByUsecaseIds is NOT called.
-  //   d) Result is ok and the tree has no subsystem nodes.
-  //   e) All top-level modules appear at root and their links are placed correctly
-  //      (no boundary logic needed since there are no subsystem nodes).
+  // loading entirely.
   // ---------------------------------------------------------------------------
   describe('Scenario H2 — no subsystems: raw links fetched, virtual segment services not called', () => {
     let services: QueryServices;
 
     beforeEach(() => {
-      // No subsystems; all modules are top-level; only raw links are relevant.
       services = makeServices({
         subsystems: [],
         modules: [
@@ -358,45 +339,35 @@ describe('GetComponentsWithSubsystemsHandler', () => {
   });
 
   // ---------------------------------------------------------------------------
-  // Scenario H3 — Initial state SS( m3, m4 ): virtual segments fetched and combined
+  // Scenario H3 — Initial state SS( m3, m4 ): SLS segments fetched and placed
   //
-  // This is the core two-layer filtering scenario.  The handler:
+  // Handler flow:
   //   Pass 2a — loads raw links (always): [L1_RAW, L2_RAW, L4_RAW]
-  //   Pass 2b — loads virtual segments (hasSubsystems=true): [L2_OUT, L3_IN, L4_VIRT]
-  //   Handler filter — keeps only virtual segments with a subsystem endpoint:
-  //     L2_OUT passes  (dst=SS.systemId ∈ subsystemIds)
-  //     L3_IN  passes  (src=SS.systemId ∈ subsystemIds)
-  //     L4_VIRT drops  (src=M3, dst=M4 — neither is a subsystem ID)
-  //   flat.dataLinks = [L1_RAW, L2_RAW, L4_RAW, L2_OUT, L3_IN]
+  //   Pass 2b — loads SLS segments (hasSubsystems=true): [SLS_L2_OUT, SLS_L3_IN]
+  //   flat.dataLinks = [L1_RAW, L2_RAW, L4_RAW]  ← raw only, no SLS mixed in
+  //   slsSegments    = [SLS_L2_OUT, SLS_L3_IN]
   //
-  // Then buildSubsystemTree applies levelNodeIds:
-  //   Root level  (levelNodeIds = {M1,M2,SS}):
-  //     L1_RAW passes   (M1=cat-1, M2=cat-1)
-  //     L2_OUT passes   (M2=cat-1, SS=cat-2)
-  //     L2_RAW dropped  (M3 not in levelNodeIds at root)
-  //   SS level (levelNodeIds = {M3,M4,SS}):
-  //     L4_RAW passes   (M3=cat-1, M4=cat-1)
-  //     L3_IN  passes   (SS=cat-3, M3=cat-1)
-  //     L2_RAW dropped  (M2 not in levelNodeIds at SS level)
-  //     L4_VIRT absent  (was filtered by handler before reaching tree builder)
+  // buildSubsystemTree places links:
+  //   Root dataLinks:          L1_RAW (m1/m2 both cat-1)
+  //   Root subsystemDataLinks: SLS_L2_OUT (m2=cat-1, SS=cat-2)
+  //   Root dropped:            L2_RAW (m3 not visible at root)
+  //   SS dataLinks:            L4_RAW (m3+m4 both cat-1)
+  //   SS subsystemDataLinks:   SLS_L3_IN (SS=cat-3, m3=cat-1)
+  //   SS dropped:              L2_RAW (m2 not visible at SS level)
   //
   // Key things being verified:
   //   a) Virtual segment services ARE called when subsystems exist.
-  //   b) The non-boundary virtual L4_VIRT (m3→m4) is filtered out by the handler
-  //      and does NOT appear in the SS-level dataLinks.
-  //   c) The boundary-crossing raw L2_RAW (m2→m3) is naturally dropped by the
-  //      tree builder's levelNodeIds filter and does NOT appear at any level.
-  //   d) The outside virtual L2_OUT appears at root, the inside virtual L3_IN
-  //      and non-boundary raw L4_RAW appear at SS level.
+  //   b) SLS segments appear in subsystemDataLinks, not dataLinks.
+  //   c) Boundary-crossing raw L2_RAW is dropped by the tree builder.
   // ---------------------------------------------------------------------------
-  describe('Scenario H3 — initial state SS(m3,m4): virtual segments fetched and combined with raw links', () => {
+  describe('Scenario H3 — initial state SS(m3,m4): SLS segments fetched and folded into dataLinks', () => {
     let services: QueryServices;
     let result: Awaited<
       ReturnType<GetComponentsWithSubsystemsHandler['handle']>
     >;
 
     beforeEach(async () => {
-      services = makeServices(); // defaults: SS only, m1..m4, rawDataLinks=[L1,L2_RAW,L4], virtualDataLinks=[L2_OUT,L3_IN,L4_VIRT]
+      services = makeServices(); // defaults: SS only, m1..m4, virtualDataLinks=[SLS_L2_OUT, SLS_L3_IN]
       result = await new GetComponentsWithSubsystemsHandler(services).handle(
         makeQuery(),
       );
@@ -418,50 +389,45 @@ describe('GetComponentsWithSubsystemsHandler', () => {
       expect(result.kind).toBe(RESULT_KIND.Ok);
     });
 
-    it('places the non-boundary raw link L1_RAW (m1→m2) at root level', () => {
+    it('places the non-boundary raw link L1_RAW (m1→m2) at root dataLinks', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       expect(collectDataLinkIds(result.data)).toContain(L1_RAW.systemId);
     });
 
-    it('places the outside virtual segment L2_OUT (m2→SS) at root level', () => {
+    it('places the outside SLS segment SLS_L2_OUT (m2→SS) at root dataLinks', () => {
+      if (result.kind !== RESULT_KIND.Ok) return;
+      expect(collectDataLinkIds(result.data)).toContain(SLS_L2_OUT.systemId);
+    });
+
+    it('SLS_L2_OUT IS in root dataLinks (folded into dataLinks array)', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
-      expect(collectDataLinkIds(result.data)).toContain(L2_OUT.systemId);
+      expect(collectDataLinkIds(result.data)).toContain(SLS_L2_OUT.systemId);
     });
 
     it('drops the boundary-crossing raw link L2_RAW (m2→m3) — not visible at root', () => {
-      // m3 is inside SS; its systemId is not in root-level levelNodeIds.
-      // buildSubsystemTree drops this raw link because neither endpoint appears
-      // in a single level's node ID set.
       if (result.kind !== RESULT_KIND.Ok) return;
       expect(collectDataLinkIds(result.data)).not.toContain(L2_RAW.systemId);
     });
 
-    it('places the inside virtual segment L3_IN (SS→m3) at SS level', () => {
+    it('places the inside SLS segment SLS_L3_IN (SS→m3) at SS dataLinks', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
-      expect(collectDataLinkIds(ss.children)).toContain(L3_IN.systemId);
+      expect(collectDataLinkIds(ss.children)).toContain(SLS_L3_IN.systemId);
     });
 
-    it('places the non-boundary raw link L4_RAW (m3→m4) at SS level', () => {
-      // L4_RAW is a raw link where both endpoints are direct modules of SS.
-      // buildSubsystemTree places it at SS level (both in category 1 there).
+    it('SLS_L3_IN IS in SS dataLinks (folded into dataLinks array)', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
-      expect(collectDataLinkIds(ss.children)).toContain(L4_RAW.systemId);
+      expect(collectDataLinkIds(ss.children)).toContain(SLS_L3_IN.systemId);
     });
 
-    it('does NOT place the non-boundary virtual L4_VIRT (m3→m4) at SS level', () => {
-      // The handler's subsystem-endpoint filter drops L4_VIRT before passing
-      // the flat model to buildSubsystemTree.  L4_VIRT has src=M3, dst=M4 —
-      // neither is in subsystemIds = {SS.systemId} — so it is excluded from
-      // extraDataLinks.  L4_RAW (same logical connection, raw source) covers it.
+    it('places the non-boundary raw link L4_RAW (m3→m4) at SS dataLinks', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
-      expect(collectDataLinkIds(ss.children)).not.toContain(L4_VIRT.systemId);
+      expect(collectDataLinkIds(ss.children)).toContain(L4_RAW.systemId);
     });
 
-    it('drops the boundary-crossing raw link L2_RAW (m2→m3) at SS level too', () => {
-      // m2 is not inside SS — it is not in SS-level levelNodeIds.
+    it('drops the boundary-crossing raw link L2_RAW (m2→m3) at SS dataLinks too', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
       expect(collectDataLinkIds(ss.children)).not.toContain(L2_RAW.systemId);
@@ -471,35 +437,26 @@ describe('GetComponentsWithSubsystemsHandler', () => {
   // ---------------------------------------------------------------------------
   // Scenario H4 — Edit session adds SS1: SS1 appears in the tree
   //
-  // After the edit session overlay has run, the query services reflect the new
-  // state of the file:
+  // After the edit session overlay has run:
   //   - subsystemQueryService.findAll() returns [SS, SS1(parentId=SS)]
-  //   - spfModuleQueryService.findByUsecaseIds() returns m1..m6 (m5,m6 inside SS1)
-  //   - findDataLinkSegmentsByUsecaseIds() returns the SS1 boundary segments
-  //     plus the original SS segments
-  //
-  // Handler filter pass — virtual segments with a subsystem endpoint:
-  //   L2_OUT passes  (dst=SS  ∈ {SS, SS1})
-  //   L3_IN  passes  (src=SS  ∈ {SS, SS1})
-  //   L5_OUT passes  (dst=SS1 ∈ {SS, SS1})
-  //   L6_IN  passes  (src=SS1 ∈ {SS, SS1})
-  //   L4_VIRT drops  (M3, M4  — no subsystem endpoint)
-  //   L7_VIRT drops  (M5, M6  — no subsystem endpoint)
+  //   - spfModuleQueryService returns m1..m6 (m5,m6 inside SS1)
+  //   - findDataLinkSegmentsByUsecaseIds() returns all 4 SLS segments
   //
   // buildSubsystemTree places links:
-  //   Root:  L1_RAW, L2_OUT
-  //   SS:    L3_IN, L4_RAW, L5_OUT     (L5_OUT: M4=cat-1, SS1=cat-2)
-  //   SS1:   L6_IN, L7_RAW             (L6_IN: SS1=cat-3, M5=cat-1)
-  //   Dropped: L2_RAW (boundary M2→M3), L4_RAW2 (boundary M4→M5)
+  //   Root dataLinks:         L1_RAW
+  //   Root subsystemDataLinks: SLS_L2_OUT
+  //   SS dataLinks:           L4_RAW
+  //   SS subsystemDataLinks:  SLS_L3_IN, SLS_L5_OUT
+  //   SS1 dataLinks:          L7_RAW
+  //   SS1 subsystemDataLinks: SLS_L6_IN
+  //   Dropped: L2_RAW (boundary M2→M3), L5_RAW (boundary M4→M5)
   //
   // Key things being verified:
   //   a) SS1 appears as a child subsystem of SS.
   //   b) m5 and m6 are placed inside SS1.
-  //   c) Outside virtual L5_OUT is placed at SS level and inside virtual L6_IN
-  //      at SS1 level.
-  //   d) Non-boundary raw L7_RAW (m5→m6) is placed at SS1 level.
-  //   e) Boundary-crossing raw L4_RAW2 (m4→m5) is dropped by the tree builder.
-  //   f) Non-boundary virtual L7_VIRT is filtered out by the handler.
+  //   c) SLS_L5_OUT appears at SS subsystemDataLinks, SLS_L6_IN at SS1 subsystemDataLinks.
+  //   d) L5_RAW (boundary crossing) is dropped by the tree builder.
+  //   e) L7_RAW (non-boundary inside SS1) is placed at SS1 dataLinks.
   // ---------------------------------------------------------------------------
   describe('Scenario H4 — edit session adds SS1: new subsystem appears in tree', () => {
     let result: Awaited<
@@ -515,10 +472,10 @@ describe('GetComponentsWithSubsystemsHandler', () => {
           makeModule(M3, SS),
           makeModule(M4, SS),
           makeModule(M5, SS1),
-          makeModule(M6, SS1), // new modules added by overlay
+          makeModule(M6, SS1),
         ],
-        rawDataLinks: [L1_RAW, L2_RAW, L4_RAW, L4_RAW2, L7_RAW],
-        virtualDataLinks: [L2_OUT, L3_IN, L4_VIRT, L5_OUT, L6_IN, L7_VIRT],
+        rawDataLinks: [L1_RAW, L2_RAW, L4_RAW, L5_RAW, L7_RAW],
+        virtualDataLinks: [SLS_L2_OUT, SLS_L3_IN, SLS_L5_OUT, SLS_L6_IN],
       });
       result = await new GetComponentsWithSubsystemsHandler(services).handle(
         makeQuery(),
@@ -548,53 +505,37 @@ describe('GetComponentsWithSubsystemsHandler', () => {
       ).toEqual([M5, M6]);
     });
 
-    it('places the outside virtual L5_OUT (m4→SS1) at SS level', () => {
-      // m4 is a direct module child of SS (category 1) and SS1 is a direct
-      // child subsystem of SS (category 2) — both visible at the SS level.
+    it('places the outside SLS segment SLS_L5_OUT (m4→SS1) at SS dataLinks', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
-      expect(collectDataLinkIds(ss.children)).toContain(L5_OUT.systemId);
+      expect(collectDataLinkIds(ss.children)).toContain(SLS_L5_OUT.systemId);
     });
 
-    it('drops the boundary-crossing raw link L4_RAW2 (m4→m5) at SS level', () => {
-      // m5 is inside SS1, not a direct child of SS — it is not in SS-level
-      // levelNodeIds.  The virtual pair L5_OUT/L6_IN represents this connection.
+    it('drops the boundary-crossing raw link L5_RAW (m4→m5) at SS dataLinks', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
-      expect(collectDataLinkIds(ss.children)).not.toContain(L4_RAW2.systemId);
+      expect(collectDataLinkIds(ss.children)).not.toContain(L5_RAW.systemId);
     });
 
-    it('places the inside virtual L6_IN (SS1→m5) at SS1 level', () => {
-      // SS1.systemId = category 3 at SS1 level; m5 = category 1.
+    it('places the inside SLS segment SLS_L6_IN (SS1→m5) at SS1 dataLinks', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
       const ss1 = ss.children.subsystems.find(s => Number(s.systemId) === SS1)!;
-      expect(collectDataLinkIds(ss1.children)).toContain(L6_IN.systemId);
+      expect(collectDataLinkIds(ss1.children)).toContain(SLS_L6_IN.systemId);
     });
 
-    it('places the non-boundary raw L7_RAW (m5→m6) at SS1 level', () => {
-      // Both m5 and m6 are direct module children of SS1 (category 1).
+    it('places the non-boundary raw L7_RAW (m5→m6) at SS1 dataLinks', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
       const ss1 = ss.children.subsystems.find(s => Number(s.systemId) === SS1)!;
       expect(collectDataLinkIds(ss1.children)).toContain(L7_RAW.systemId);
     });
 
-    it('does NOT include the non-boundary virtual L7_VIRT (m5→m6) at SS1 level', () => {
-      // The handler filters out L7_VIRT because neither M5 nor M6 is in
-      // subsystemIds = {SS, SS1}.  L7_RAW (same connection, raw source) is used.
-      if (result.kind !== RESULT_KIND.Ok) return;
-      const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
-      const ss1 = ss.children.subsystems.find(s => Number(s.systemId) === SS1)!;
-      expect(collectDataLinkIds(ss1.children)).not.toContain(L7_VIRT.systemId);
-    });
-
-    it('drops the boundary-crossing raw L4_RAW2 (m4→m5) at SS1 level too', () => {
-      // m4 is not inside SS1 — not in SS1-level levelNodeIds.
+    it('drops the boundary-crossing raw L5_RAW (m4→m5) at SS1 dataLinks too', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
       const ss1 = ss.children.subsystems.find(s => Number(s.systemId) === SS1)!;
-      expect(collectDataLinkIds(ss1.children)).not.toContain(L4_RAW2.systemId);
+      expect(collectDataLinkIds(ss1.children)).not.toContain(L5_RAW.systemId);
     });
   });
 
@@ -602,18 +543,13 @@ describe('GetComponentsWithSubsystemsHandler', () => {
   // Scenario H5 — Edit session deletes SS1: tree reverts to initial state
   //
   // After the overlay removes SS1 and its modules (m5, m6), the query services
-  // return the same data as the initial state:
-  //   - findAll() returns only [SS]
-  //   - findByUsecaseIds (modules) returns only m1..m4
-  //   - findDataLinkSegmentsByUsecaseIds returns only the original SS segments
-  //     (no L5_OUT, L6_IN, L7_VIRT — those belong to the now-deleted SS1)
-  //   - Raw links return only L1_RAW, L2_RAW, L4_RAW (no L4_RAW2, L7_RAW)
+  // return the same data as the initial state (SS only, m1..m4).
   //
   // Key things being verified:
   //   a) SS1 does NOT appear in the tree (findAll returned only [SS]).
   //   b) SS still contains m3 and m4 as its only modules.
-  //   c) SS-level dataLinks match the initial state: [L3_IN, L4_RAW].
-  //   d) No remnants of SS1 (no L5_OUT, L6_IN, L7_RAW) appear anywhere.
+  //   c) SS-level dataLinks contains L4_RAW, subsystemDataLinks contains SLS_L3_IN.
+  //   d) No remnants of SS1 (no SLS_L5_OUT, SLS_L6_IN, L7_RAW) appear anywhere.
   // ---------------------------------------------------------------------------
   describe('Scenario H5 — edit session deletes SS1: tree reverts to initial state', () => {
     let result: Awaited<
@@ -622,7 +558,7 @@ describe('GetComponentsWithSubsystemsHandler', () => {
 
     beforeEach(async () => {
       // Services reflect post-overlay state: SS1 removed, m5/m6 removed,
-      // no SS1 virtual segments.  Matches exactly the initial-state defaults.
+      // no SS1 SLS segments.  Matches exactly the initial-state defaults.
       const services = makeServices(); // defaults already represent the initial state
       result = await new GetComponentsWithSubsystemsHandler(services).handle(
         makeQuery(),
@@ -649,21 +585,25 @@ describe('GetComponentsWithSubsystemsHandler', () => {
       ).toEqual([M3, M4]);
     });
 
-    it('SS-level dataLinks contain L3_IN and L4_RAW — no SS1 segments', () => {
+    it('SS dataLinks contains L4_RAW (mod link) and SLS_L3_IN (SLS) — no SS1 segments', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
       const ss = result.data.subsystems.find(s => Number(s.systemId) === SS)!;
-      const ids = collectDataLinkIds(ss.children);
-      expect(ids).toContain(L3_IN.systemId);
-      expect(ids).toContain(L4_RAW.systemId);
-      expect(ids).not.toContain(L5_OUT.systemId); // SS1 outside segment — gone
-      expect(ids).not.toContain(L6_IN.systemId); // SS1 inside segment — gone
+      expect(collectDataLinkIds(ss.children)).toEqual([
+        SLS_L3_IN.systemId,
+        L4_RAW.systemId,
+      ]);
+      expect(collectDataLinkIds(ss.children)).not.toContain(
+        SLS_L5_OUT.systemId,
+      );
+      expect(collectDataLinkIds(ss.children)).not.toContain(SLS_L6_IN.systemId);
     });
 
-    it('root-level dataLinks are unchanged: L1_RAW and L2_OUT only', () => {
+    it('root-level dataLinks has L1_RAW (mod link) and SLS_L2_OUT (SLS) only', () => {
       if (result.kind !== RESULT_KIND.Ok) return;
-      expect(collectDataLinkIds(result.data)).toEqual(
-        [L1_RAW.systemId, L2_OUT.systemId].sort((a, b) => a - b),
-      );
+      expect(collectDataLinkIds(result.data)).toEqual([
+        L1_RAW.systemId,
+        SLS_L2_OUT.systemId,
+      ]);
     });
 
     it('m5 and m6 are not present anywhere in the tree', () => {
diff --git a/packages/core/tests/unit/domain/services/subsystem-links/subsystem-boundary-path.service.spec.ts b/packages/core/tests/unit/domain/services/subsystem-links/subsystem-boundary-path.service.spec.ts
deleted file mode 100644
index 16b252101..000000000
--- a/packages/core/tests/unit/domain/services/subsystem-links/subsystem-boundary-path.service.spec.ts
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-import {describe, it, expect} from '@jest/globals';
-import {
-  SubsystemBoundaryPathService,
-  type PathInput,
-  type PathOutput,
-} from '../../../../../src/domain/services/subsystem-data-links/subsystem-boundary-path.service.js';
-import {PORT_IO_TYPE} from '../../../../../src/domain/entities/common/enums/port-io-type.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeInput(
-  sourceNodeSystemId: number,
-  destinationNodeSystemId: number,
-  parentEntries: [number, number | null][],
-): PathInput {
-  return {
-    sourceNodeSystemId,
-    destinationNodeSystemId,
-    nodeParentMap: new Map<number, number | null>(parentEntries),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('SubsystemBoundaryPathService', () => {
-  // -------------------------------------------------------------------------
-  // Case 1: Source at top level, dest inside one subsystem (LCA = null)
-  // -------------------------------------------------------------------------
-  describe('source at top level, dest inside one subsystem', () => {
-    it('returns correct nodeSequence and requiredPortType', () => {
-      // Layout:
-      //   ModuleA (1) — parentId null  (top level)
-      //   SubsystemY (10) — parentId null
-      //   ModuleB (2)  — parentId 10
-      const input = makeInput(1, 2, [
-        [1, null],
-        [10, null],
-        [2, 10],
-      ]);
-
-      const result: PathOutput = SubsystemBoundaryPathService.compute(input);
-
-      expect(result.nodeSequence).toEqual([1, 10, 2]);
-      expect(result.requiredPortType.size).toBe(1);
-      expect(result.requiredPortType.get(10)).toBe(PORT_IO_TYPE.InputOutput);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Case 2: Both modules in different top-level subsystems (spec worked example)
-  // Layout:
-  //   ModuleA (1) → SubsystemInner (10) → SubsystemOuter (20) (top level)
-  //   ModuleB (2) → SubsystemY (30) (top level)
-  // Expected: nodeSequence = [1, 10, 20, 30, 2]
-  //   SubsystemInner (10) → OutputInput  (exit)
-  //   SubsystemOuter (20) → OutputInput  (exit)
-  //   SubsystemY (30)     → InputOutput  (enter)
-  // -------------------------------------------------------------------------
-  describe('spec worked example — source nested 2 levels, dest nested 1 level, LCA = null', () => {
-    it('returns [ModuleA, SubsystemInner, SubsystemOuter, SubsystemY, ModuleB]', () => {
-      const input = makeInput(1, 2, [
-        [1, 10], // ModuleA inside SubsystemInner
-        [10, 20], // SubsystemInner inside SubsystemOuter
-        [20, null], // SubsystemOuter at top level
-        [2, 30], // ModuleB inside SubsystemY
-        [30, null], // SubsystemY at top level
-      ]);
-
-      const result = SubsystemBoundaryPathService.compute(input);
-
-      expect(result.nodeSequence).toEqual([1, 10, 20, 30, 2]);
-
-      expect(result.requiredPortType.get(10)).toBe(PORT_IO_TYPE.OutputInput);
-      expect(result.requiredPortType.get(20)).toBe(PORT_IO_TYPE.OutputInput);
-      expect(result.requiredPortType.get(30)).toBe(PORT_IO_TYPE.InputOutput);
-      expect(result.requiredPortType.size).toBe(3);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Case 3: Both modules share an outer subsystem (LCA is non-null node)
-  //   SubsystemOuter (20) — parentId null
-  //   SubsystemA (10)     — parentId 20
-  //   SubsystemB (30)     — parentId 20
-  //   ModuleA (1)         — parentId 10
-  //   ModuleB (2)         — parentId 30
-  // exitChain:  [10, 20] trimmed to [10]  (stops before LCA 20)
-  // entryChain: [30, 20] trimmed to [30]  (stops before LCA 20)
-  // nodeSequence: [1, 10, 30, 2]
-  //   10 → OutputInput, 30 → InputOutput
-  // -------------------------------------------------------------------------
-  describe('both modules share outer subsystem (LCA = SubsystemOuter)', () => {
-    it('does not include the LCA in nodeSequence and assigns correct port types', () => {
-      const input = makeInput(1, 2, [
-        [1, 10], // ModuleA inside SubsystemA
-        [10, 20], // SubsystemA inside SubsystemOuter
-        [2, 30], // ModuleB inside SubsystemB
-        [30, 20], // SubsystemB inside SubsystemOuter
-        [20, null], // SubsystemOuter at top level
-      ]);
-
-      const result = SubsystemBoundaryPathService.compute(input);
-
-      expect(result.nodeSequence).toEqual([1, 10, 30, 2]);
-      expect(result.requiredPortType.get(10)).toBe(PORT_IO_TYPE.OutputInput);
-      expect(result.requiredPortType.get(30)).toBe(PORT_IO_TYPE.InputOutput);
-      expect(result.requiredPortType.size).toBe(2);
-      // LCA (20) must not appear in the sequence
-      expect(result.nodeSequence).not.toContain(20);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Case 4: Deep nesting on both sides with a non-null LCA
-  //   Root (5)    — parentId null
-  //   Mid_L (11)  — parentId 5
-  //   Mid_R (21)  — parentId 5
-  //   Inner_L (12)— parentId 11
-  //   Inner_R (22)— parentId 21
-  //   ModuleA (1) — parentId 12
-  //   ModuleB (2) — parentId 22
-  //
-  // exitChain (from 1):  [12, 11, 5] trimmed (LCA=5) → [12, 11]
-  // entryChain (from 2): [22, 21, 5] trimmed (LCA=5) → [22, 21]
-  // reversed entryChain:                              → [21, 22]
-  // nodeSequence: [1, 12, 11, 21, 22, 2]
-  // -------------------------------------------------------------------------
-  describe('deep nesting both sides with non-null LCA', () => {
-    it('returns correct sequence excluding LCA node', () => {
-      const input = makeInput(1, 2, [
-        [1, 12],
-        [12, 11],
-        [11, 5],
-        [5, null],
-        [2, 22],
-        [22, 21],
-        [21, 5],
-      ]);
-
-      const result = SubsystemBoundaryPathService.compute(input);
-
-      expect(result.nodeSequence).toEqual([1, 12, 11, 21, 22, 2]);
-
-      expect(result.requiredPortType.get(12)).toBe(PORT_IO_TYPE.OutputInput);
-      expect(result.requiredPortType.get(11)).toBe(PORT_IO_TYPE.OutputInput);
-      expect(result.requiredPortType.get(21)).toBe(PORT_IO_TYPE.InputOutput);
-      expect(result.requiredPortType.get(22)).toBe(PORT_IO_TYPE.InputOutput);
-      expect(result.requiredPortType.size).toBe(4);
-      expect(result.nodeSequence).not.toContain(5);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Case 5: One module inside one subsystem, other module at top level
-  //         (mirror of Case 1 but source is the nested one)
-  //   ModuleA (1) — parentId 10
-  //   SubsystemX (10) — parentId null
-  //   ModuleB (2) — parentId null
-  // exitChain (from 1): [10] trimmed to [10]
-  // entryChain (from 2): [] (already at top)
-  // nodeSequence: [1, 10, 2]
-  // -------------------------------------------------------------------------
-  describe('source nested one level, dest at top level', () => {
-    it('returns correct sequence with exit subsystem only', () => {
-      const input = makeInput(1, 2, [
-        [1, 10],
-        [10, null],
-        [2, null],
-      ]);
-
-      const result = SubsystemBoundaryPathService.compute(input);
-
-      expect(result.nodeSequence).toEqual([1, 10, 2]);
-      expect(result.requiredPortType.get(10)).toBe(PORT_IO_TYPE.OutputInput);
-      expect(result.requiredPortType.size).toBe(1);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Case 6: Both in different top-level subsystems, no intermediate nesting
-  //   ModuleA (1) — parentId 10
-  //   SubsystemA (10) — parentId null
-  //   ModuleB (2) — parentId 20
-  //   SubsystemB (20) — parentId null
-  // nodeSequence: [1, 10, 20, 2]
-  // -------------------------------------------------------------------------
-  describe('both in different top-level subsystems (simple case)', () => {
-    it('returns nodeSequence with one exit and one entry subsystem', () => {
-      const input = makeInput(1, 2, [
-        [1, 10],
-        [10, null],
-        [2, 20],
-        [20, null],
-      ]);
-
-      const result = SubsystemBoundaryPathService.compute(input);
-
-      expect(result.nodeSequence).toEqual([1, 10, 20, 2]);
-      expect(result.requiredPortType.get(10)).toBe(PORT_IO_TYPE.OutputInput);
-      expect(result.requiredPortType.get(20)).toBe(PORT_IO_TYPE.InputOutput);
-      expect(result.requiredPortType.size).toBe(2);
-    });
-  });
-});
diff --git a/packages/core/tests/unit/domain/services/subsystem-links/subsystem-data-link-derivation.service.spec.ts b/packages/core/tests/unit/domain/services/subsystem-links/subsystem-data-link-derivation.service.spec.ts
new file mode 100644
index 000000000..2a6994b0d
--- /dev/null
+++ b/packages/core/tests/unit/domain/services/subsystem-links/subsystem-data-link-derivation.service.spec.ts
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import {describe, expect, it} from '@jest/globals';
+import {PORT_IO_TYPE} from '../../../../../src/domain/entities/common/enums/port-io-type.js';
+import {
+  SubsystemDataLinkDerivationService,
+  type SegmentDescriptor,
+} from '../../../../../src/domain/services/subsystem-data-links/subsystem-data-link-derivation.service.js';
+
+function derive(
+  sourceNodeSystemId: number,
+  destinationNodeSystemId: number,
+  entries: [number, number | null][],
+): SegmentDescriptor[] {
+  return SubsystemDataLinkDerivationService.compute({
+    sourceNodeSystemId,
+    destinationNodeSystemId,
+    nodeParentMap: new Map(entries),
+  });
+}
+
+describe('SubsystemDataLinkDerivationService', () => {
+  it('derives entry segments from a top-level source to a nested destination', () => {
+    expect(
+      derive(1, 2, [
+        [1, null],
+        [10, null],
+        [2, 10],
+      ]),
+    ).toEqual([
+      {
+        sourceNodeSystemId: 1,
+        destinationNodeSystemId: 10,
+        sourceBoundaryPortType: null,
+        destBoundaryPortType: PORT_IO_TYPE.InputOutput,
+        position: 0,
+      },
+      {
+        sourceNodeSystemId: 10,
+        destinationNodeSystemId: 2,
+        sourceBoundaryPortType: PORT_IO_TYPE.InputOutput,
+        destBoundaryPortType: null,
+        position: 1,
+      },
+    ]);
+  });
+
+  it('derives exit and entry segments across separate top-level subsystems', () => {
+    expect(
+      derive(1, 2, [
+        [1, 10],
+        [10, null],
+        [2, 20],
+        [20, null],
+      ]),
+    ).toEqual([
+      {
+        sourceNodeSystemId: 1,
+        destinationNodeSystemId: 10,
+        sourceBoundaryPortType: null,
+        destBoundaryPortType: PORT_IO_TYPE.OutputInput,
+        position: 0,
+      },
+      {
+        sourceNodeSystemId: 10,
+        destinationNodeSystemId: 20,
+        sourceBoundaryPortType: PORT_IO_TYPE.OutputInput,
+        destBoundaryPortType: PORT_IO_TYPE.InputOutput,
+        position: 1,
+      },
+      {
+        sourceNodeSystemId: 20,
+        destinationNodeSystemId: 2,
+        sourceBoundaryPortType: PORT_IO_TYPE.InputOutput,
+        destBoundaryPortType: null,
+        position: 2,
+      },
+    ]);
+  });
+
+  it('excludes a shared outer subsystem from derived segments', () => {
+    expect(
+      derive(1, 2, [
+        [1, 10],
+        [10, 20],
+        [2, 30],
+        [30, 20],
+        [20, null],
+      ]),
+    ).toEqual([
+      {
+        sourceNodeSystemId: 1,
+        destinationNodeSystemId: 10,
+        sourceBoundaryPortType: null,
+        destBoundaryPortType: PORT_IO_TYPE.OutputInput,
+        position: 0,
+      },
+      {
+        sourceNodeSystemId: 10,
+        destinationNodeSystemId: 30,
+        sourceBoundaryPortType: PORT_IO_TYPE.OutputInput,
+        destBoundaryPortType: PORT_IO_TYPE.InputOutput,
+        position: 1,
+      },
+      {
+        sourceNodeSystemId: 30,
+        destinationNodeSystemId: 2,
+        sourceBoundaryPortType: PORT_IO_TYPE.InputOutput,
+        destBoundaryPortType: null,
+        position: 2,
+      },
+    ]);
+  });
+
+  it('preserves all boundaries for deep nesting with a common ancestor', () => {
+    const segments = derive(1, 2, [
+      [1, 12],
+      [12, 11],
+      [11, 5],
+      [5, null],
+      [2, 22],
+      [22, 21],
+      [21, 5],
+    ]);
+
+    expect(
+      segments.map(segment => [
+        segment.sourceNodeSystemId,
+        segment.destinationNodeSystemId,
+        segment.position,
+      ]),
+    ).toEqual([
+      [1, 12, 0],
+      [12, 11, 1],
+      [11, 21, 2],
+      [21, 22, 3],
+      [22, 2, 4],
+    ]);
+    expect(
+      segments.map(segment => [
+        segment.sourceBoundaryPortType,
+        segment.destBoundaryPortType,
+      ]),
+    ).toEqual([
+      [null, PORT_IO_TYPE.OutputInput],
+      [PORT_IO_TYPE.OutputInput, PORT_IO_TYPE.OutputInput],
+      [PORT_IO_TYPE.OutputInput, PORT_IO_TYPE.InputOutput],
+      [PORT_IO_TYPE.InputOutput, PORT_IO_TYPE.InputOutput],
+      [PORT_IO_TYPE.InputOutput, null],
+    ]);
+  });
+
+  it('derives exit segments from a nested source to a top-level destination', () => {
+    expect(
+      derive(1, 2, [
+        [1, 10],
+        [10, null],
+        [2, null],
+      ]),
+    ).toEqual([
+      {
+        sourceNodeSystemId: 1,
+        destinationNodeSystemId: 10,
+        sourceBoundaryPortType: null,
+        destBoundaryPortType: PORT_IO_TYPE.OutputInput,
+        position: 0,
+      },
+      {
+        sourceNodeSystemId: 10,
+        destinationNodeSystemId: 2,
+        sourceBoundaryPortType: PORT_IO_TYPE.OutputInput,
+        destBoundaryPortType: null,
+        position: 1,
+      },
+    ]);
+  });
+
+  it('returns no segments for endpoints in the same subsystem context', () => {
+    expect(
+      derive(1, 2, [
+        [1, 10],
+        [2, 10],
+        [10, null],
+      ]),
+    ).toEqual([]);
+  });
+});
diff --git a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/queries/subsystem/db-subsystem-query-service.ts b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/queries/subsystem/db-subsystem-query-service.ts
index 3e63218e5..1f7c038c3 100644
--- a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/queries/subsystem/db-subsystem-query-service.ts
+++ b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/queries/subsystem/db-subsystem-query-service.ts
@@ -8,7 +8,7 @@ import type {
   SubsystemQueryService,
   SubsystemReadModel,
   ControlLinkReadModel,
-  DataLinkReadModel,
+  SubsystemDataLinkReadModel,
 } from '@arc/core';
 import {Result, IssueFactory} from '@arc/core';
 import {resolveActiveSessionId} from '../shared/session-resolver.js';
@@ -131,10 +131,16 @@ export class DbSubsystemQueryService implements SubsystemQueryService {
     }
   }
 
+  /**
+   * Returns virtual data-link segments from subsystem_data_links for the given usecases.
+   * Same scoping and overlay pattern as findControlLinkSegmentsByUsecaseIds.
+   * Returns SubsystemDataLinkReadModel (not DataLinkReadModel) so callers get the
+   * dataLinkSystemId parent reference and the correct type.
+   */
   async findDataLinkSegmentsByUsecaseIds(
     usecaseSystemIds: number[],
     fileSystemId: number,
-  ): Promise<Result<DataLinkReadModel[]>> {
+  ): Promise<Result<SubsystemDataLinkReadModel[]>> {
     if (usecaseSystemIds.length === 0) return Result.ok([]);
     try {
       const sessionId = await resolveActiveSessionId(
@@ -181,7 +187,7 @@ export class DbSubsystemQueryService implements SubsystemQueryService {
       });
       return Result.ok(
         links.map(dl =>
-          UseCaseQueryMappers.mapToComponentDataLinkReadModel(dl),
+          UseCaseQueryMappers.mapToSubsystemDataLinkReadModel(dl),
         ),
       );
     } catch (error) {
diff --git a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/queries/usecase/usecase-query-mappers.ts b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/queries/usecase/usecase-query-mappers.ts
index b69819a2e..6d5a3dd60 100644
--- a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/queries/usecase/usecase-query-mappers.ts
+++ b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/queries/usecase/usecase-query-mappers.ts
@@ -11,6 +11,7 @@ import type {
   IntentReadModel,
   DataLinkReadModel,
   ControlLinkReadModel,
+  SubsystemDataLinkReadModel,
 } from '@arc/core';
 import {PORT_IO_TYPE} from '@arc/core';
 import type {ValueDefinitionRow, NodeRow} from '../../entity-schema/index.js';
@@ -78,6 +79,19 @@ export const UseCaseQueryMappers = {
     };
   },
 
+  mapToSubsystemDataLinkReadModel(
+    dl: DataLinkBase & {dataLinkSystemId?: number | null},
+  ): SubsystemDataLinkReadModel {
+    return {
+      systemId: dl.systemId,
+      sourceNodeSystemId: dl.sourceNodeSystemId,
+      destinationNodeSystemId: dl.destinationNodeSystemId,
+      sourcePortSystemId: dl.sourcePortSystemId,
+      destinationPortSystemId: dl.destinationPortSystemId,
+      dataLinkSystemId: dl.dataLinkSystemId ?? null,
+    };
+  },
+
   mapToComponentControlLinkReadModel(
     cl: ControlLinkBase,
   ): ControlLinkReadModel {
diff --git a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/data-link/data-link.repository.ts b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/data-link/data-link.repository.ts
index e7e03e14c..2c8a27bb8 100644
--- a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/data-link/data-link.repository.ts
+++ b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/data-link/data-link.repository.ts
@@ -12,8 +12,14 @@ import type {
   SessionChanged,
   EditOptions,
   SubsystemDataRouteContext,
+  BoundaryPortPayload,
+} from '@arc/core';
+import {
+  CHANGE_OPERATION,
+  DataLink,
+  LINK_TYPE,
+  SubsystemDataLink,
 } from '@arc/core';
-import {DataLink, LINK_TYPE, SubsystemDataLink} from '@arc/core';
 import type {DataLinkBase} from '../../entity-schema/usecase-data/Links/data-link.js';
 import type {EffectiveSubsystemDataLinkRow} from '../../fetchers/link-overlay-fetcher.js';
 import {LinkOverlayFetcher} from '../../fetchers/link-overlay-fetcher.js';
@@ -61,6 +67,7 @@ export class TypeOrmDataLinkRepository implements DataLinkRepository {
   private readonly writer: PendingChangeWriter;
   private readonly manager: EntityManager;
   private readonly uow: UnitOfWork;
+  private readonly editActionsQueryService: EditActionsQueryService;
 
   constructor(
     writer: PendingChangeWriter,
@@ -71,6 +78,7 @@ export class TypeOrmDataLinkRepository implements DataLinkRepository {
     this.manager = manager;
     this.uow = uow;
     const editActions = new EditActionsQueryService(this.manager);
+    this.editActionsQueryService = editActions;
     this.linkFetcher = new LinkOverlayFetcher(this.manager, editActions);
     this.nodeFetcher = new NodeOverlayFetcher(this.manager, editActions);
   }
@@ -398,4 +406,226 @@ export class TypeOrmDataLinkRepository implements DataLinkRepository {
       deleted: changed.deleted.map(row => baseToDataLink(row)),
     };
   }
+
+  async createDataLink(
+    dataLink: DataLink,
+    boundaryPortPayloads: BoundaryPortPayload[],
+    options?: EditOptions,
+  ): Promise<void> {
+    const {session, groupId} = this.uow.getWriteContext();
+    const fileSystemId = dataLink.fileSystemId;
+    const writer = this.requireWriter();
+
+    for (const bp of boundaryPortPayloads) {
+      await writer.writeCreate(
+        {
+          targetTable: ENTITY_NAMES.Node,
+          targetSystemId: bp.nodeSystemId,
+          aggregateId: dataLink.systemId,
+          payload: {
+            type: 'subsystem',
+            parentId: bp.nodeParentId ?? null,
+            fileSystemId: bp.fileSystemId,
+          },
+          ...options,
+        },
+        session.sessionId,
+        groupId,
+        this.manager,
+      );
+    }
+
+    for (const bp of boundaryPortPayloads) {
+      await writer.writeCreate(
+        {
+          targetTable: ENTITY_NAMES.DataPort,
+          targetSystemId: bp.portSystemId,
+          aggregateId: dataLink.systemId,
+          payload: {
+            dataPortId: bp.dataPortId,
+            portIoType: bp.portIoType,
+            isStatic: false,
+            name: '',
+            nodeSystemId: bp.nodeSystemId,
+            fileSystemId: bp.fileSystemId,
+          },
+          ...options,
+        },
+        session.sessionId,
+        groupId,
+        this.manager,
+      );
+    }
+
+    await writer.writeCreate(
+      {
+        targetTable: ENTITY_NAMES.DataLink,
+        targetSystemId: dataLink.systemId,
+        aggregateId: dataLink.systemId,
+        payload: {
+          sourceNodeSystemId: dataLink.sourceNodeSystemId,
+          destinationNodeSystemId: dataLink.destinationNodeSystemId,
+          sourcePortSystemId: dataLink.sourcePortSystemId,
+          destinationPortSystemId: dataLink.destinationPortSystemId,
+          linkType: dataLink.linkType,
+          sourceSubgraphSystemId: dataLink.sourceSubgraphSystemId,
+          destSubgraphSystemId: dataLink.destSubgraphSystemId,
+          isEc: dataLink.isEc ?? null,
+          fileSystemId,
+        },
+        ...options,
+      },
+      session.sessionId,
+      groupId,
+      this.manager,
+    );
+
+    for (const sls of dataLink.subsystemDataLinks) {
+      await writer.writeCreate(
+        {
+          targetTable: ENTITY_NAMES.SubsystemDataLink,
+          targetSystemId: sls.systemId,
+          aggregateId: dataLink.systemId,
+          payload: {
+            sourceNodeSystemId: sls.sourceNodeSystemId,
+            destinationNodeSystemId: sls.destinationNodeSystemId,
+            sourcePortSystemId: sls.sourcePortSystemId,
+            destinationPortSystemId: sls.destinationPortSystemId,
+            dataLinkSystemId: sls.dataLinkSystemId,
+            fileSystemId,
+          },
+          ...options,
+        },
+        session.sessionId,
+        groupId,
+        this.manager,
+      );
+    }
+  }
+
+  async findByPortPair(
+    sourcePortSystemId: number,
+    destPortSystemId: number,
+    fileSystemId: number,
+  ): Promise<{
+    systemId: number;
+    isDeleted: boolean;
+    payload: Record<string, unknown>;
+  } | null> {
+    const {session} = this.uow.getWriteContext();
+    const sessionId = session.sessionId;
+
+    const baseRow = await this.manager
+      .createQueryBuilder()
+      .select('dl.systemId')
+      .from(ENTITY_NAMES.DataLink, 'dl')
+      .where(
+        'dl.sourcePortSystemId = :srcPort AND dl.destinationPortSystemId = :dstPort AND dl.fileSystemId = :fileSystemId',
+        {srcPort: sourcePortSystemId, dstPort: destPortSystemId, fileSystemId},
+      )
+      .getRawOne<{dl_system_id: number}>();
+
+    if (baseRow) {
+      const systemId = Number(baseRow.dl_system_id);
+      const actions = await this.editActionsQueryService.getByTable(
+        sessionId,
+        ENTITY_NAMES.DataLink,
+      );
+      const isDeleted = actions.some(
+        a =>
+          a.targetSystemId === systemId &&
+          a.operation === CHANGE_OPERATION.Delete,
+      );
+      return {
+        systemId,
+        isDeleted,
+        payload: {
+          sourcePortSystemId,
+          destinationPortSystemId: destPortSystemId,
+          fileSystemId,
+        },
+      };
+    }
+
+    const actions = await this.editActionsQueryService.getByTable(
+      sessionId,
+      ENTITY_NAMES.DataLink,
+    );
+    for (const action of actions) {
+      if (action.operation !== CHANGE_OPERATION.Create) continue;
+      const p = action.newValue as Record<string, unknown>;
+      if (
+        Number(p['sourcePortSystemId']) === sourcePortSystemId &&
+        Number(p['destinationPortSystemId']) === destPortSystemId &&
+        Number(p['fileSystemId']) === fileSystemId
+      ) {
+        return {systemId: action.targetSystemId, isDeleted: false, payload: p};
+      }
+    }
+
+    return null;
+  }
+
+  async reactivateDataLink(
+    systemId: number,
+    aggregateId: number,
+    payload: Record<string, unknown>,
+    options?: EditOptions,
+  ): Promise<void> {
+    const {session, groupId} = this.uow.getWriteContext();
+    const writer = this.requireWriter();
+    // eslint-disable-next-line custom/no-raw-persistence-queries -- conditional UPDATE with IS NULL on valid_until cannot be expressed with TypeORM QueryBuilder
+    await this.manager.query(
+      `UPDATE edit_actions SET valid_until = $1 WHERE session_id = $2 AND target_system_id = $3 AND field_path IS NULL AND valid_until IS NULL`,
+      [new Date().toISOString(), session.sessionId, systemId],
+    );
+    await writer.writeCreate(
+      {
+        targetTable: ENTITY_NAMES.DataLink,
+        targetSystemId: systemId,
+        aggregateId,
+        payload,
+        ...options,
+      },
+      session.sessionId,
+      groupId,
+      this.manager,
+    );
+  }
+
+  async createSubsystemDataLink(
+    sls: SubsystemDataLink,
+    options?: EditOptions,
+  ): Promise<void> {
+    const {session, groupId} = this.uow.getWriteContext();
+    const writer = this.requireWriter();
+    await writer.writeCreate(
+      {
+        targetTable: ENTITY_NAMES.SubsystemDataLink,
+        targetSystemId: sls.systemId,
+        aggregateId: sls.systemId,
+        payload: {
+          sourceNodeSystemId: sls.sourceNodeSystemId,
+          destinationNodeSystemId: sls.destinationNodeSystemId,
+          sourcePortSystemId: sls.sourcePortSystemId,
+          destinationPortSystemId: sls.destinationPortSystemId,
+          dataLinkSystemId: null,
+          fileSystemId: sls.fileSystemId,
+        },
+        ...options,
+      },
+      session.sessionId,
+      groupId,
+      this.manager,
+    );
+  }
+
+  private requireWriter(): NonNullable<typeof this.writer> {
+    if (!this.writer) {
+      throw new Error(
+        'PendingChangeWriter is required for write operations on DataLinkRepository',
+      );
+    }
+    return this.writer;
+  }
 }
diff --git a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/module/module.repository.ts b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/module/module.repository.ts
index 57f707691..688a78caa 100644
--- a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/module/module.repository.ts
+++ b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/module/module.repository.ts
@@ -8,6 +8,7 @@ import type {
   ModuleRepository,
   UnitOfWork,
   EditOptions,
+  PortIoType,
   SpfModuleBase,
   PayloadUpdate,
 } from '@arc/core';
@@ -303,6 +304,35 @@ export class TypeOrmModuleRepository implements ModuleRepository {
     });
   }
 
+  async findModulePortsForLink(
+    moduleSystemId: number,
+    fileSystemId: number,
+  ): Promise<{
+    subgraphSystemId: number;
+    ports: {systemId: number; portIoType: PortIoType}[];
+  } | null> {
+    const sessionId = this.uow.getWriteContext().session.sessionId;
+    const modules = await this.spfModuleFetcher.fetchMany(
+      fileSystemId,
+      sessionId,
+      {systemId: moduleSystemId},
+    );
+    const module = modules.at(0);
+    if (module === undefined) return null;
+    const dataPorts = await this.portFetcher.fetchDataPorts(
+      moduleSystemId,
+      fileSystemId,
+      sessionId,
+    );
+    return {
+      subgraphSystemId: module.subgraphSystemId,
+      ports: dataPorts.map(dp => ({
+        systemId: dp.systemId,
+        portIoType: dp.portIoType,
+      })),
+    };
+  }
+
   async renameModule(
     moduleSystemId: number,
     alias: string,
diff --git a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/subgraph/subgraph.repository.ts b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/subgraph/subgraph.repository.ts
index cfad8e0da..51131603b 100644
--- a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/subgraph/subgraph.repository.ts
+++ b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/subgraph/subgraph.repository.ts
@@ -212,6 +212,25 @@ export class TypeOrmSubgraphRepository implements SubgraphRepository {
     return rows.map(r => this.hydrate(r));
   }
 
+  async getUsecaseSystemIdForSubgraph(
+    subgraphSystemId: number,
+    fileSystemId: number,
+  ): Promise<number | null> {
+    const row = await this.manager
+      .createQueryBuilder()
+      .select('ucs.usecase_system_id', 'usecaseSystemId')
+      .from(ENTITY_NAMES.UseCaseSubgraph, 'ucs')
+      .innerJoin(
+        ENTITY_NAMES.UseCase,
+        'uc',
+        'uc.systemId = ucs.usecaseSystemId AND uc.fileSystemId = :fileSystemId',
+        {fileSystemId},
+      )
+      .where('ucs.subgraphSystemId = :subgraphSystemId', {subgraphSystemId})
+      .getRawOne<{usecaseSystemId: number}>();
+    return row ? Number(row.usecaseSystemId) : null;
+  }
+
   async findChangedInSession(
     fileSystemId: number,
   ): Promise<SessionChanged<Subgraph>> {
diff --git a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/subsystem/subsystem.repository.ts b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/subsystem/subsystem.repository.ts
index 70e1596ed..e495b6654 100644
--- a/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/subsystem/subsystem.repository.ts
+++ b/packages/infrastructure/persistence/src/persistence-typeorm-sqllite/repositories/subsystem/subsystem.repository.ts
@@ -6,10 +6,12 @@
 import type {EntityManager} from 'typeorm';
 import type {
   EditOptions,
+  PortIoType,
   SubsystemControlPortRef,
   SubsystemRepository,
   UnitOfWork,
 } from '@arc/core';
+import {CHANGE_OPERATION} from '@arc/core';
 import {ENTITY_NAMES} from '../../entity-schema/entity-table-names.js';
 import type {PendingChangeWriter} from '../../services/pending-change-writer.js';
 import {EditActionsQueryService} from '../../queries/edit-session/edit-actions-query-service.js';
@@ -22,6 +24,7 @@ export class TypeOrmSubsystemRepository implements SubsystemRepository {
   private readonly uow: UnitOfWork;
   private readonly portFetcher: PortOverlayFetcher;
   private readonly subsystemFetcher: SubsystemOverlayFetcher;
+  private readonly editActionsQs: EditActionsQueryService;
 
   constructor(
     writer: PendingChangeWriter,
@@ -32,6 +35,7 @@ export class TypeOrmSubsystemRepository implements SubsystemRepository {
     this.manager = manager;
     this.uow = uow;
     const editActions = new EditActionsQueryService(this.manager);
+    this.editActionsQs = editActions;
     this.subsystemFetcher = new SubsystemOverlayFetcher(
       this.manager,
       editActions,
@@ -118,4 +122,99 @@ export class TypeOrmSubsystemRepository implements SubsystemRepository {
       }
     }
   }
+
+  async getAllNodesWithParents(
+    fileSystemId: number,
+  ): Promise<Map<number, number | null>> {
+    const rows = await this.manager
+      .createQueryBuilder()
+      .select(['n.systemId', 'n.parentId'])
+      .from(ENTITY_NAMES.Node, 'n')
+      .where('n.fileSystemId = :fileSystemId', {fileSystemId})
+      .getRawMany<{n_system_id: number; n_parent_id: number | null}>();
+    const map = new Map<number, number | null>();
+    for (const row of rows) {
+      map.set(
+        Number(row.n_system_id),
+        row.n_parent_id === null ? null : Number(row.n_parent_id),
+      );
+    }
+    return map;
+  }
+
+  async getPortIoType(
+    portSystemId: number,
+    fileSystemId: number,
+  ): Promise<PortIoType | null> {
+    const sessionId = this.uow.getWriteContext().session.sessionId;
+
+    // Check session overlay first — a staged CREATE wins over the base table
+    const actions = await this.editActionsQs.getByTable(
+      sessionId,
+      ENTITY_NAMES.DataPort,
+    );
+    for (const action of actions) {
+      if (
+        action.operation === CHANGE_OPERATION.Create &&
+        action.targetSystemId === portSystemId
+      ) {
+        const p = action.newValue as Record<string, unknown>;
+        if (Number(p['fileSystemId']) === fileSystemId) {
+          return (p['portIoType'] as PortIoType) ?? null;
+        }
+      }
+    }
+
+    // Fall through to base table
+    const row = await this.manager
+      .createQueryBuilder()
+      .select(['dp.portIoType'])
+      .from(ENTITY_NAMES.DataPort, 'dp')
+      .where('dp.systemId = :systemId AND dp.fileSystemId = :fileSystemId', {
+        systemId: portSystemId,
+        fileSystemId,
+      })
+      .getRawOne<{dp_port_io_type: string}>();
+
+    return (row?.dp_port_io_type as PortIoType) ?? null;
+  }
+
+  async isPortOccupiedAsSource(
+    portSystemId: number,
+    fileSystemId: number,
+  ): Promise<boolean> {
+    const count = await this.manager
+      .createQueryBuilder()
+      .select('1')
+      .from(ENTITY_NAMES.SubsystemDataLink, 'sls')
+      .where(
+        'sls.sourcePortSystemId = :portSystemId AND sls.fileSystemId = :fileSystemId',
+        {portSystemId, fileSystemId},
+      )
+      .getCount();
+    return count > 0;
+  }
+
+  async isPortOccupiedAsDest(
+    portSystemId: number,
+    fileSystemId: number,
+  ): Promise<boolean> {
+    const count = await this.manager
+      .createQueryBuilder()
+      .select('1')
+      .from(ENTITY_NAMES.SubsystemDataLink, 'sls')
+      .where(
+        'sls.destinationPortSystemId = :portSystemId AND sls.fileSystemId = :fileSystemId',
+        {portSystemId, fileSystemId},
+      )
+      .getCount();
+    return count > 0;
+  }
+
+  async portExists(
+    portSystemId: number,
+    fileSystemId: number,
+  ): Promise<boolean> {
+    return (await this.getPortIoType(portSystemId, fileSystemId)) !== null;
+  }
 }
diff --git a/packages/infrastructure/persistence/tests/integration/repositories/data-link/data-link-edit.repository.integration.spec.ts b/packages/infrastructure/persistence/tests/integration/repositories/data-link/data-link-edit.repository.integration.spec.ts
new file mode 100644
index 000000000..4a79944a4
--- /dev/null
+++ b/packages/infrastructure/persistence/tests/integration/repositories/data-link/data-link-edit.repository.integration.spec.ts
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+import type {DataSource, QueryRunner} from 'typeorm';
+import {PORT_IO_TYPE} from '@arc/core';
+import {
+  setupIntegrationTest,
+  teardownIntegrationTest,
+  setupEachTest,
+  getTestDataSource,
+  getTestRepository,
+} from '../../helpers/test-database-setup.js';
+import {TypeOrmDataLinkRepository} from '../../../../src/persistence-typeorm-sqllite/repositories/data-link/data-link.repository.js';
+import {EditActionsQueryService} from '../../../../src/persistence-typeorm-sqllite/queries/edit-session/edit-actions-query-service.js';
+import {PendingChangeWriter} from '../../../../src/persistence-typeorm-sqllite/services/pending-change-writer.js';
+import {PendingChangeCache} from '../../../../src/persistence-typeorm-sqllite/services/pending-change-cache.js';
+import {ProjectSchema} from '../../../../src/persistence-typeorm-sqllite/entity-schema/project-data/project.schema.js';
+import {ArcDbFileSchema} from '../../../../src/persistence-typeorm-sqllite/entity-schema/project-data/arc-db-file.schema.js';
+import {
+  ProjectSessionSchema,
+  SESSION_MODE,
+  SESSION_STATUS,
+} from '../../../../src/persistence-typeorm-sqllite/entity-schema/edit-session/project-session.schema.js';
+import {
+  describe,
+  it,
+  expect,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  afterEach,
+} from '@jest/globals';
+
+const FILE_ID = 100;
+const SUBGRAPH_ID = 400;
+const NODE_A = 201;
+const NODE_B = 202;
+const PORT_SRC = 301;
+const PORT_DST = 302;
+const DATA_LINK_ID = 601;
+
+async function seedProjectAndFile(ds: DataSource) {
+  await getTestRepository(ProjectSchema).save({
+    systemId: 1,
+    name: 'P',
+    description: '',
+    type: 'Offline',
+  });
+  await getTestRepository(ArcDbFileSchema).save({
+    systemId: FILE_ID,
+    projectSystemId: 1,
+    fileName: 'f.acdb',
+    description: '',
+    metadata: '{}',
+    isTarget: true,
+    lastReservedId: 0,
+  });
+}
+
+async function seedSession(ds: DataSource): Promise<number> {
+  const row = await getTestRepository(ProjectSessionSchema).save({
+    fileSystemId: FILE_ID,
+    userId: 'u',
+    clientId: 'c',
+    sessionMode: SESSION_MODE.Designer,
+    status: SESSION_STATUS.Active,
+    endedAt: null,
+  });
+  return row.sessionId;
+}
+
+async function seedFkDependencies(ds: DataSource) {
+  await ds.query(
+    `INSERT INTO subgraphs (system_id, name, subgraph_id, is_imported, file_system_id) VALUES (?, 'sg', 1, 0, ?)`,
+    [SUBGRAPH_ID, FILE_ID],
+  );
+  await ds.query(
+    `INSERT INTO nodes (system_id, type, parent_id, file_system_id) VALUES (?, 'module', NULL, ?)`,
+    [NODE_A, FILE_ID],
+  );
+  await ds.query(
+    `INSERT INTO nodes (system_id, type, parent_id, file_system_id) VALUES (?, 'module', NULL, ?)`,
+    [NODE_B, FILE_ID],
+  );
+  await ds.query(
+    `INSERT INTO data_ports (system_id, data_port_id, port_io_type, is_static, node_system_id) VALUES (?, 1, ?, 1, ?)`,
+    [PORT_SRC, PORT_IO_TYPE.Output, NODE_A],
+  );
+  await ds.query(
+    `INSERT INTO data_ports (system_id, data_port_id, port_io_type, is_static, node_system_id) VALUES (?, 2, ?, 1, ?)`,
+    [PORT_DST, PORT_IO_TYPE.Input, NODE_B],
+  );
+}
+
+async function seedDeletedDataLink(
+  ds: DataSource,
+  sessionId: number,
+  groupId: string,
+) {
+  await ds.query(
+    `INSERT INTO data_links (system_id, source_node_system_id, destination_node_system_id, source_port_system_id, destination_port_system_id, link_type, source_subgraph_system_id, dest_subgraph_system_id, file_system_id) VALUES (?, ?, ?, ?, ?, 'INTRA_SUBGRAPH', ?, ?, ?)`,
+    [
+      DATA_LINK_ID,
+      NODE_A,
+      NODE_B,
+      PORT_SRC,
+      PORT_DST,
+      SUBGRAPH_ID,
+      SUBGRAPH_ID,
+      FILE_ID,
+    ],
+  );
+  await ds.query(
+    `INSERT INTO edit_actions (session_id, aggregate_id, target_system_id, target_table, operation, field_path, new_value, source, change_status, group_id) VALUES (?, ?, ?, 'DataLink', 'DELETE', NULL, '{}', 'MANUAL', 'STAGED', ?)`,
+    [sessionId, DATA_LINK_ID, DATA_LINK_ID, groupId],
+  );
+}
+
+function makeRepo(
+  qr: QueryRunner,
+  sessionId: number,
+): TypeOrmDataLinkRepository {
+  const cache = new PendingChangeCache();
+  const editSvc = new EditActionsQueryService(qr.manager);
+  const writer = new PendingChangeWriter(editSvc, cache);
+  const uow = {
+    getWriteContext: () => ({
+      session: {
+        sessionId,
+        fileSystemId: FILE_ID,
+        mode: SESSION_MODE.Designer,
+        projectId: '1',
+      },
+      groupId: 'test-group',
+    }),
+  } as any;
+  return new TypeOrmDataLinkRepository(writer, qr.manager, uow);
+}
+
+describe('TypeOrmDataLinkRepository (integration)', () => {
+  let ds: DataSource;
+  let qr: QueryRunner;
+  let sessionId: number;
+
+  beforeAll(async () => {
+    await setupIntegrationTest();
+  });
+  afterAll(async () => {
+    await teardownIntegrationTest();
+  });
+  beforeEach(async () => {
+    await setupEachTest();
+    ds = getTestDataSource();
+    await seedProjectAndFile(ds);
+    await seedFkDependencies(ds);
+    sessionId = await seedSession(ds);
+    qr = ds.createQueryRunner();
+    await qr.connect();
+  });
+  afterEach(async () => {
+    if (qr) {
+      await qr.release();
+    }
+  });
+
+  it('findByPortPair returns null when no link exists', async () => {
+    const repo = makeRepo(qr, sessionId);
+    const result = await repo.findByPortPair(PORT_SRC, PORT_DST, FILE_ID);
+    expect(result).toBeNull();
+  });
+
+  it('findByPortPair returns {isDeleted: true} when a base link has a DELETE edit_action', async () => {
+    await seedDeletedDataLink(ds, sessionId, 'grp1');
+    const repo = makeRepo(qr, sessionId);
+    const result = await repo.findByPortPair(PORT_SRC, PORT_DST, FILE_ID);
+    expect(result).not.toBeNull();
+    expect(result!.isDeleted).toBe(true);
+    expect(result!.systemId).toBe(DATA_LINK_ID);
+  });
+
+  it('reactivateDataLink supersedes DELETE row and inserts new CREATE row', async () => {
+    await seedDeletedDataLink(ds, sessionId, 'grp1');
+    await qr.startTransaction();
+    const repo = makeRepo(qr, sessionId);
+    const payload = {
+      sourcePortSystemId: PORT_SRC,
+      destinationPortSystemId: PORT_DST,
+      fileSystemId: FILE_ID,
+    };
+    await repo.reactivateDataLink(DATA_LINK_ID, DATA_LINK_ID, payload);
+    await qr.commitTransaction();
+
+    const rows: Array<Record<string, unknown>> = await ds.query(
+      `SELECT * FROM edit_actions WHERE session_id = ? AND target_system_id = ? AND target_table = 'DataLink' ORDER BY change_id`,
+      [sessionId, DATA_LINK_ID],
+    );
+    expect(rows.length).toBe(2);
+    const deleteRow = rows.find(r => r['operation'] === 'DELETE');
+    const createRow = rows.find(r => r['operation'] === 'CREATE');
+    expect(deleteRow).toBeDefined();
+    expect(createRow).toBeDefined();
+    expect(deleteRow!['valid_until']).not.toBeNull();
+    expect(createRow!['valid_until']).toBeNull();
+    expect(createRow!['change_status']).toBe('STAGED');
+  });
+});