diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d05ffef..32623e6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -39,3 +39,15 @@ jobs:
 
       - name: "Tests"
         run: just test
+
+      - name: "Frontend Tests"
+        run: just test-frontend
+
+      - name: "Compile Check"
+        run: just compile
+
+      - name: "Validate Data"
+        run: just validate-data
+
+      - name: "Docker Compose Config"
+        run: just docker-config
diff --git a/README.md b/README.md
index 5e0338c..b732c2a 100644
--- a/README.md
+++ b/README.md
@@ -22,7 +22,7 @@ Each instruction can be dismissed as you go, similar to how Google Maps lets you
 |**Flask**|Turns our Python code into a running website|
 |**NetworkX**|Models the building as a graph and calculates the shortest path between rooms|
 |**HTML & CSS**|Structure and styling of the webpage|
-|**SVG / Leaflet.js**|Draws the animated blue route line over the floor plan image|
+|**Leaflet.js**|Draws the building grid, route line, and route markers|
 |**JSON**|Text files that store our building data (rooms, coordinates, connections)|
 |**uv**|Package manager — installs and manages Python libraries|
 |**Git**|Version control — tracks changes so the team can collaborate without overwriting each other|
@@ -35,8 +35,8 @@ The building is modeled as a **graph** — locations are **nodes** and the walki
 2. **name** — the human-readable label (e.g., `"5.102"` or `"Main Staircase"`), displayed in directions
 3. **type** — the category of location (e.g., `"room"`, `"staircase"`, `"elevator"`, `"waypoint"`, `"spine"`). A `"spine"` node represents a main hallway/backbone connector used to route movement through the building, and the field is used to filter and categorize nodes
 4. **building** — the building code (e.g., `"NPB"`), allowing multi-building support
-5. **coords** — the pixel coordinates `[x, y]` on the floor plan image, used to draw the blue route line
-6. **floor** — the floor number the node is on, allowing multi-floor pathfinding and filtering
+5. **coords** — the `[x, y]` coordinates used to draw the blue route line on the map grid
+6. **floor** — the floor number the node is on, allowing multi-floor pathfinding and filtering. The browser map preview supports one floor at a time; multi-floor routes still show their step-by-step directions.
 
 Each edge stores 4 things:
 
@@ -75,15 +75,13 @@ campus_navigator/
 │   │
 │   ├── static/                  ← Files the browser downloads directly
 │   │   ├── css/
-│   │   │   └── style.css        ← Page styling
-│   │   ├── js/
-│   │   │   └── map.js           ← Draws the blue route line (Leaflet.js logic)
-│   │   └── img/
-│   │       └── floorplan.png    ← The floor plan image displayed on screen
+│   │   │   └── styles.css       ← Page styling
+│   │   └── js/
+│   │       ├── directions.js    ← Step-by-step direction cards
+│   │       └── map.js            ← Draws the route on a Leaflet grid
 │   │
 │   └── templates/               ← HTML pages Flask serves to the user
-│       ├── base.html            ← Shared page skeleton (nav bar, footer, etc.)
-│       └── index.html           ← The main search + map page
+│       └── index.html           ← The search, directions, and map page
 │
 └── data/                        ← Building data — treated like a database
     ├── nodes.json               ← Every room/intersection with its name and coordinates
@@ -116,7 +114,7 @@ graph_manager.py returns: text directions + pixel coordinates
 routes.py passes results to index.html (via Flask's render_template)
         ↓
 index.html displays the step-by-step text directions
-map.js reads the coordinates and draws the blue line over floorplan.png
+map.js reads the coordinates and draws the blue line over a coordinate grid
         ↓
 User sees directions on screen ✓
 ```
@@ -143,7 +141,7 @@ Write the Python function that loads the JSON files, builds the NetworkX graph,
 
 **Workspace: `app/templates/`, `app/static/`**
 
-Build the HTML/CSS pages and write the JavaScript (`map.js`) that draws the animated blue line over the floor plan. Keep it mobile-friendly — users will be on their phones while walking.
+Build the HTML/CSS pages and write the JavaScript that draws the animated blue line over the coordinate grid. Keep it mobile-friendly. Users will be on their phones while walking.
 
 ### 🔌 Integration (1 person)
 
diff --git a/app/logic/data_entry.py b/app/logic/data_entry.py
index 913980b..48d14d5 100644
--- a/app/logic/data_entry.py
+++ b/app/logic/data_entry.py
@@ -2,9 +2,11 @@
 from pathlib import Path
 
 BASE_DIR = Path(__file__).resolve().parent
-DATA_DIR = BASE_DIR / "data"
+REPO_ROOT = BASE_DIR.parents[1]
+DATA_DIR = REPO_ROOT / "data"
 NODES_FILE = DATA_DIR / "nodes.json"
 EDGES_FILE = DATA_DIR / "edges.json"
+DEFAULT_BUILDING = "NPB"
 
 
 # JSON helpers
@@ -55,6 +57,7 @@ def add_node():
         "id": node_id,
         "name": label,
         "type": node_type,
+        "building": DEFAULT_BUILDING,
         "coords": [x, y],
         "floor": floor,
     }
diff --git a/app/logic/graph_manager.py b/app/logic/graph_manager.py
index 88a8874..00f24b5 100644
--- a/app/logic/graph_manager.py
+++ b/app/logic/graph_manager.py
@@ -147,6 +147,11 @@ def get_directions(start, end):
                 directions.append(
                     f"Take the stairs from floor {current_node['floor']} to floor {next_node['floor']}."
                 )
+            elif (
+                current_node.get("type") == "elevator"
+                and next_node.get("type") == "elevator"
+            ):
+                directions.append(edge_data["instruction"])
             else:
                 directions.append(
                     f"Move from floor {current_node['floor']} to floor {next_node['floor']}."
diff --git a/app/routes.py b/app/routes.py
index 1de759a..cd887f5 100644
--- a/app/routes.py
+++ b/app/routes.py
@@ -18,6 +18,7 @@ def directions():
     steps = None
     coordinates = None
     floor_bounds = None
+    map_error = None
     error = None
     entrance = request.form.get("entrance")
     classroom = request.form.get("classroom")
@@ -32,9 +33,16 @@ def directions():
                 steps = result["directions"]
                 coordinates = result["coordinates"]
                 if coordinates:
-                    building = entrance.split("_")[0]
-                    floor = coordinates[0]["floor"]
-                    floor_bounds = get_floor_bounds(building, floor)
+                    route_floors = {coordinate["floor"] for coordinate in coordinates}
+                    if len(route_floors) > 1:
+                        map_error = (
+                            "Map preview is unavailable for routes spanning multiple floors. "
+                            "Follow the directions panel for this route."
+                        )
+                    else:
+                        building = entrance.split("_")[0]
+                        floor = coordinates[0]["floor"]
+                        floor_bounds = get_floor_bounds(building, floor)
         except RuntimeError as e:
             error = str(e)
     entrances, classrooms = get_options()
@@ -43,6 +51,7 @@ def directions():
         steps=steps,
         coordinates=coordinates,
         floor_bounds=floor_bounds,
+        map_error=map_error,
         error=error,
         entranceOptions=entrances,
         classroomOptions=classrooms,
diff --git a/app/static/css/styles.css b/app/static/css/styles.css
index a464b4b..1d9257a 100644
--- a/app/static/css/styles.css
+++ b/app/static/css/styles.css
@@ -97,7 +97,7 @@ button:hover {
   margin: 10px 0;
   padding-left: 20px;
 }
-.ateps-box li {
+.steps-box li {
   margin-bottom: 8px;
   color: #555;
 }
@@ -111,7 +111,7 @@ button:hover {
   box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
 }
 
-.direction-box h2 {
+.directions-box h2 {
   margin-top: 0;
   color: #0c2340;
   font-size: 18px;
@@ -146,7 +146,7 @@ button:hover {
   background: #d4ffd4;
   border-left: 5px solid #28a745;
 }
-#next--step-btn {
+#next-step-btn {
   margin-top: 10px;
   padding: 8px 12px;
   background: #007bff;
@@ -155,7 +155,7 @@ button:hover {
   border-radius: 5px;
   cursor: pointer;
 }
-#next--step-btn:hover {
+#next-step-btn:hover {
   background: #0056b3;
 }
 
@@ -181,3 +181,25 @@ html {
   width: 100%;
   height: 100vh;
 }
+
+@media (max-width: 768px) {
+  .container {
+    flex-direction: column;
+    height: auto;
+    min-height: 100vh;
+  }
+
+  .left-panel,
+  .right-panel {
+    box-sizing: border-box;
+    width: 100%;
+  }
+
+  .right-panel {
+    height: 50vh;
+  }
+
+  #map {
+    height: 50vh;
+  }
+}
diff --git a/app/static/js/directions.js b/app/static/js/directions.js
index db205da..7a2a0bb 100644
--- a/app/static/js/directions.js
+++ b/app/static/js/directions.js
@@ -2,37 +2,42 @@ document.addEventListener("DOMContentLoaded", () => {
   if (typeof directionSteps === "undefined" || !directionSteps.length) return;
 
   const container = document.getElementById("directions-card-container");
+  if (!container) return;
+
   let currentIndex = 0;
 
   function renderSteps(index) {
-    container.innerHTML = "";
-
-    if (index >= directionSteps.length) {
-      container.innerHTML = `
-            <div class="direction-card arrived">
-                <h3>You have arrived!</h3>
-                </div>
-                 `;
-      return;
-    }
-
-    const stepText = directionSteps[index];
+    container.replaceChildren();
 
     const card = document.createElement("div");
-    card.className = "direction-card active";
-
-    card.innerHTML = `
-        <h3>Step ${index + 1}</h3>
-        <p>${stepText}</p>
-        <button id="next-step-btn">Next</button>
-         `;
+    card.className =
+      index >= directionSteps.length
+        ? "direction-card arrived"
+        : "direction-card active";
+
+    const heading = document.createElement("h3");
+    heading.textContent =
+      index >= directionSteps.length
+        ? "You have arrived!"
+        : `Step ${index + 1}`;
+    card.appendChild(heading);
+
+    if (index < directionSteps.length) {
+      const paragraph = document.createElement("p");
+      paragraph.textContent = directionSteps[index];
+      card.appendChild(paragraph);
+
+      const nextButton = document.createElement("button");
+      nextButton.id = "next-step-btn";
+      nextButton.textContent = "Next";
+      nextButton.addEventListener("click", () => {
+        currentIndex++;
+        renderSteps(currentIndex);
+      });
+      card.appendChild(nextButton);
+    }
 
     container.appendChild(card);
-
-    document.getElementById("next-step-btn").addEventListener("click", () => {
-      currentIndex++;
-      renderSteps(currentIndex);
-    });
   }
 
   renderSteps(currentIndex);
diff --git a/app/static/js/map.js b/app/static/js/map.js
index 34ae9d0..9475ac7 100644
--- a/app/static/js/map.js
+++ b/app/static/js/map.js
@@ -1,12 +1,31 @@
 document.addEventListener("DOMContentLoaded", () => {
-  if (!window.routeCoordinates || !window.floorBounds) {
+  const { routeCoordinates, floorBounds } = window;
+  if (!routeCoordinates || !floorBounds) {
     console.error("routeCoordinates or floorBounds missing from template");
     return;
   }
+  if (!window.L) {
+    console.error("Leaflet is missing from the page");
+    return;
+  }
+  if (!Array.isArray(routeCoordinates)) {
+    console.error("routeCoordinates must be an array");
+    return;
+  }
+
+  const floors = new Set(
+    routeCoordinates
+      .map((coordinate) => coordinate.floor)
+      .filter((floor) => floor !== undefined),
+  );
+  if (floors.size > 1) {
+    console.error("Map preview only supports routes on one floor");
+    return;
+  }
 
   // Initialize map with simple CRS
-  const map = L.map("map", {
-    crs: L.CRS.Simple,
+  const map = window.L.map("map", {
+    crs: window.L.CRS.Simple,
     minZoom: -2,
     maxZoom: 4,
     zoomControl: true,
@@ -26,7 +45,7 @@ document.addEventListener("DOMContentLoaded", () => {
 
     // Vertical lines
     for (let x = 0; x <= floorBounds.width; x += gridSize) {
-      L.polyline(
+      window.L.polyline(
         [
           [0, x],
           [floorBounds.height, x],
@@ -41,7 +60,7 @@ document.addEventListener("DOMContentLoaded", () => {
 
     // Horizontal lines
     for (let y = 0; y <= floorBounds.height; y += gridSize) {
-      L.polyline(
+      window.L.polyline(
         [
           [y, 0],
           [y, floorBounds.width],
@@ -60,21 +79,20 @@ document.addEventListener("DOMContentLoaded", () => {
   // Convert backend coordinates → Leaflet [lat, lng]
   const latlngs = routeCoordinates.map((c) => [c.y, c.x]);
 
-  // Draw animated route line
-  const routeLine = L.polyline(latlngs, {
-    color: "blue",
-    weight: 4,
-    dashArray: "10, 10",
-    className: "animated-route",
-  }).addTo(map);
+  if (latlngs.length > 0) {
+    // Draw animated route line
+    const routeLine = window.L.polyline(latlngs, {
+      color: "blue",
+      weight: 4,
+      dashArray: "10, 10",
+      className: "animated-route",
+    }).addTo(map);
 
-  // Fit map to route
-  map.fitBounds(routeLine.getBounds(), { padding: [20, 20] });
+    // Fit map to route
+    map.fitBounds(routeLine.getBounds(), { padding: [20, 20] });
 
-  // Start + end markers
-  if (latlngs.length > 0) {
     // Start marker (green)
-    L.circleMarker(latlngs[0], {
+    window.L.circleMarker(latlngs[0], {
       radius: 6,
       color: "green",
       fillColor: "green",
@@ -82,7 +100,7 @@ document.addEventListener("DOMContentLoaded", () => {
     }).addTo(map);
 
     // End marker (red)
-    L.circleMarker(latlngs[latlngs.length - 1], {
+    window.L.circleMarker(latlngs[latlngs.length - 1], {
       radius: 6,
       color: "red",
       fillColor: "red",
diff --git a/app/templates/index.html b/app/templates/index.html
index 628f645..94edca7 100644
--- a/app/templates/index.html
+++ b/app/templates/index.html
@@ -29,7 +29,7 @@ <h1>Choose Your Options</h1>
                     </select>
                     <br>
                     <br>
-                    <button type="/directions">Get Directions</button>
+                    <button type="submit">Get Directions</button>
                     <div style="height: 30px;"></div>
                     <div class="radio-group">
                         <strong>Route:</strong>
@@ -61,7 +61,15 @@ <h2>Directions</h2>
                     {% endif %}
                 </div>
                 <div class="right-panel">
-                    {% if coordinates %}
+                    {% if map_error %}
+                        <div id="map"
+                             style="background: #f4f5f7;
+                                    display: flex;
+                                    align-items: center;
+                                    justify-content: center">
+                            <p style="color: #999;">{{ map_error }}</p>
+                        </div>
+                    {% elif coordinates %}
                         <div id="map"></div>
                         <script>
             window.routeCoordinates = {{ coordinates | tojson }};
diff --git a/justfile b/justfile
index e28c6b5..38effb8 100644
--- a/justfile
+++ b/justfile
@@ -39,9 +39,10 @@ fix:
     uvx ruff check --fix .
     just format
 
+# Release checks: `just lint`, `just format-check`, `uv run pytest`,
+# compileall, `uv run tools/validate_data.py`, and `docker compose config`.
 # THE command before pushing
-check: lint format-check test
-    uv run python -m compileall -q app run.py tools
+check: lint format-check test test-frontend compile validate-data docker-config
     @echo 'All good - ready to push'
 
 # Remove caches and build artifacts
@@ -52,10 +53,27 @@ clean:
     rm -f *.pyc *.pyo
     rm -rf dist build
 
-# Run the test suite
+# Run the Python test suite
 test:
     uv run pytest
 
+# Run browser-script tests with Node's built-in test runner
+test-frontend:
+    node --test tests/frontend/*.test.mjs
+
+# Compile Python sources
+compile:
+    uv run python -m compileall -q app run.py tools
+
+# Validate canonical graph data
+validate-data:
+    uv run tools/validate_data.py
+
+# Verify the development compose file without starting containers
+docker-config:
+    docker compose config
+    docker compose -f docker-compose.prod.yml config
+
 # Run tests with coverage report
 coverage:
-    uv run pytest --cov=app --cov-report=term-missing --cov-report=html
+    uv run pytest --cov=app --cov=tools --cov-report=term-missing --cov-report=html
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..72ecb47
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,15 @@
+import pytest
+
+from app import create_app
+
+
+@pytest.fixture
+def app():
+    app = create_app()
+    app.config.update(TESTING=True)
+    return app
+
+
+@pytest.fixture
+def client(app):
+    return app.test_client()
diff --git a/tests/frontend/directions.test.mjs b/tests/frontend/directions.test.mjs
new file mode 100644
index 0000000..326c9c9
--- /dev/null
+++ b/tests/frontend/directions.test.mjs
@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { loadDirectionsScript } from "./harness.mjs";
+
+test("directions does nothing when direction steps are missing", () => {
+  const harness = loadDirectionsScript();
+
+  assert.equal(harness.directionsContainer.children.length, 0);
+  assert.equal(harness.directionsContainer.innerHTML, "");
+  assert.equal(harness.document.getElementById("next-step-btn"), null);
+});
+
+test("directions does nothing for an empty step list", () => {
+  const harness = loadDirectionsScript({ directionSteps: [] });
+
+  assert.equal(harness.directionsContainer.children.length, 0);
+  assert.equal(harness.directionsContainer.innerHTML, "");
+});
+
+test("directions renders the first step and its ordinary instruction text", () => {
+  const instruction = "Leave the lobby and turn right toward the elevators.";
+  const harness = loadDirectionsScript({ directionSteps: [instruction] });
+  const card = harness.directionsContainer.children[0];
+  const nextButton = harness.getElementById("next-step-btn");
+
+  assert.equal(harness.directionsContainer.children.length, 1);
+  assert.equal(card.className, "direction-card active");
+  assert.equal(card.children[0].textContent, "Step 1");
+  assert.equal(card.children[1].textContent, instruction);
+  assert.equal(nextButton.textContent, "Next");
+  assert.match(harness.directionsContainer.innerHTML, /Step 1/);
+  assert.match(harness.directionsContainer.innerHTML, /Leave the lobby/);
+});
+
+test("directions renders instruction text without interpreting HTML", () => {
+  const instruction = '<img src=x onerror="alert(1)"> Turn left';
+  const harness = loadDirectionsScript({ directionSteps: [instruction] });
+  const paragraph = harness.directionsContainer.children[0].children[1];
+
+  assert.equal(paragraph.textContent, instruction);
+  assert.equal(paragraph.innerHTML, "");
+  assert.equal(
+    harness.getCreatedElements().filter((element) => element.tagName === "IMG")
+      .length,
+    0,
+  );
+  assert.doesNotMatch(harness.directionsContainer.innerHTML, /<img/);
+});
+
+test("directions advances through steps in order and then shows arrived", () => {
+  const harness = loadDirectionsScript({
+    directionSteps: [
+      "Exit the room and turn left.",
+      "Continue straight for 20 feet.",
+      "Turn right at the hallway.",
+    ],
+  });
+
+  const firstButton = harness.getElementById("next-step-btn");
+  firstButton.click();
+  assert.equal(
+    harness.directionsContainer.children[0].children[0].textContent,
+    "Step 2",
+  );
+  assert.equal(
+    harness.directionsContainer.children[0].children[1].textContent,
+    "Continue straight for 20 feet.",
+  );
+
+  const secondButton = harness.getElementById("next-step-btn");
+  secondButton.click();
+  assert.equal(
+    harness.directionsContainer.children[0].children[0].textContent,
+    "Step 3",
+  );
+  assert.equal(
+    harness.directionsContainer.children[0].children[1].textContent,
+    "Turn right at the hallway.",
+  );
+
+  const finalButton = harness.getElementById("next-step-btn");
+  finalButton.click();
+  const arrivedCard = harness.directionsContainer.children[0];
+
+  assert.equal(arrivedCard.className, "direction-card arrived");
+  assert.equal(
+    harness.directionsContainer.querySelector("h3").textContent,
+    "You have arrived!",
+  );
+  assert.equal(harness.getElementById("next-step-btn"), null);
+});
diff --git a/tests/frontend/harness.mjs b/tests/frontend/harness.mjs
new file mode 100644
index 0000000..1d59ce6
--- /dev/null
+++ b/tests/frontend/harness.mjs
@@ -0,0 +1,638 @@
+import { readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
+import { resolve, dirname, isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import vm from "node:vm";
+
+const FRONTEND_DIR = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = resolve(FRONTEND_DIR, "../..");
+const SCRIPT_PATHS = Object.freeze({
+  directions: resolve(PROJECT_ROOT, "app/static/js/directions.js"),
+  map: resolve(PROJECT_ROOT, "app/static/js/map.js"),
+});
+
+function createEventTarget() {
+  const listeners = new Map();
+
+  return {
+    addEventListener(type, listener) {
+      const callbacks = listeners.get(type) ?? [];
+      callbacks.push(listener);
+      listeners.set(type, callbacks);
+    },
+
+    removeEventListener(type, listener) {
+      const callbacks = listeners.get(type) ?? [];
+      listeners.set(
+        type,
+        callbacks.filter((callback) => callback !== listener),
+      );
+    },
+
+    dispatchEvent(eventOrType) {
+      const event =
+        typeof eventOrType === "string"
+          ? { type: eventOrType }
+          : { ...eventOrType };
+      if (!event.type) {
+        throw new TypeError("Events must have a type");
+      }
+
+      const callbacks = [...(listeners.get(event.type) ?? [])];
+      for (const callback of callbacks) {
+        callback(event);
+      }
+      return true;
+    },
+
+    listenerCount(type) {
+      return (listeners.get(type) ?? []).length;
+    },
+  };
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+class FakeElement {
+  constructor(ownerDocument, tagName) {
+    this.ownerDocument = ownerDocument;
+    this.tagName = tagName.toUpperCase();
+    this.children = [];
+    this.parentNode = null;
+    this.style = {};
+    this.className = "";
+    this.eventListeners = new Map();
+    this._id = "";
+    this._innerHTML = "";
+    this._textContent = "";
+  }
+
+  get id() {
+    return this._id;
+  }
+
+  set id(value) {
+    this.ownerDocument.unregisterId(this);
+    this._id = String(value);
+    this.ownerDocument.registerId(this);
+  }
+
+  get innerHTML() {
+    return this._innerHTML;
+  }
+
+  get outerHTML() {
+    const attributes = [
+      this.id && ` id="${this.id}"`,
+      this.className && ` class="${this.className}"`,
+    ]
+      .filter(Boolean)
+      .join("");
+    const content = this._innerHTML || escapeHtml(this._textContent);
+    return `<${this.tagName.toLowerCase()}${attributes}>${content}</${this.tagName.toLowerCase()}>`;
+  }
+
+  set innerHTML(value) {
+    this.clearChildren();
+    this._innerHTML = String(value);
+    this._textContent = "";
+
+    // This deliberately small parser gives every opening tag a fake node and
+    // preserves ids/classes needed by tests without pretending to be a browser.
+    const openingTags = /<([a-z][\w-]*)\b([^>]*)>/gi;
+    for (const match of this._innerHTML.matchAll(openingTags)) {
+      const tagName = match[1];
+      const child = this.ownerDocument.createElement(tagName);
+      const id = match[2].match(/\bid=["']([^"']+)["']/i)?.[1];
+      const className = match[2].match(/\bclass=["']([^"']+)["']/i)?.[1];
+      const text = new RegExp(
+        `<${tagName}\\b[^>]*>([^<]*)</${tagName}>`,
+        "i",
+      ).exec(this._innerHTML.slice(match.index))?.[1];
+      if (id) child.id = id;
+      if (className) child.className = className;
+      if (text?.trim()) child.textContent = text.trim();
+      this.appendChild(child);
+    }
+  }
+
+  get textContent() {
+    if (this._textContent) return this._textContent;
+    return this._innerHTML.replace(/<[^>]*>/g, "").trim();
+  }
+
+  set textContent(value) {
+    this.clearChildren();
+    this._innerHTML = "";
+    this._textContent = String(value);
+  }
+
+  appendChild(child) {
+    if (child.parentNode) {
+      child.parentNode.removeChild(child);
+    }
+    child.parentNode = this;
+    this.children.push(child);
+    this.ownerDocument.registerTree(child);
+    this._innerHTML = this.children
+      .map((element) => element.outerHTML)
+      .join("");
+    return child;
+  }
+
+  removeChild(child) {
+    const index = this.children.indexOf(child);
+    if (index === -1) return child;
+    this.children.splice(index, 1);
+    this.ownerDocument.unregisterTree(child);
+    child.parentNode = null;
+    this._innerHTML = this.children
+      .map((element) => element.outerHTML)
+      .join("");
+    return child;
+  }
+
+  clearChildren() {
+    for (const child of [...this.children]) {
+      this.removeChild(child);
+    }
+  }
+
+  replaceChildren(...children) {
+    this.clearChildren();
+    for (const child of children) this.appendChild(child);
+  }
+
+  addEventListener(type, listener) {
+    const callbacks = this.eventListeners.get(type) ?? [];
+    callbacks.push(listener);
+    this.eventListeners.set(type, callbacks);
+  }
+
+  removeEventListener(type, listener) {
+    const callbacks = this.eventListeners.get(type) ?? [];
+    this.eventListeners.set(
+      type,
+      callbacks.filter((callback) => callback !== listener),
+    );
+  }
+
+  dispatchEvent(eventOrType) {
+    const event =
+      typeof eventOrType === "string"
+        ? { type: eventOrType }
+        : { ...eventOrType };
+    if (!event.type) {
+      throw new TypeError("Events must have a type");
+    }
+    event.target ??= this;
+    event.currentTarget = this;
+
+    for (const callback of [...(this.eventListeners.get(event.type) ?? [])]) {
+      callback(event);
+    }
+    return true;
+  }
+
+  click() {
+    return this.dispatchEvent({ type: "click" });
+  }
+
+  querySelector(selector) {
+    if (selector.startsWith("#")) {
+      return this.ownerDocument.getElementById(selector.slice(1));
+    }
+    if (selector.startsWith(".")) {
+      return this.find((element) =>
+        element.className.split(/\s+/).includes(selector.slice(1)),
+      );
+    }
+    return this.find(
+      (element) => element.tagName.toLowerCase() === selector.toLowerCase(),
+    );
+  }
+
+  find(predicate) {
+    for (const child of this.children) {
+      if (predicate(child)) return child;
+      const match = child.find(predicate);
+      if (match) return match;
+    }
+    return null;
+  }
+}
+
+class FakeDocument {
+  constructor() {
+    this.createdElements = [];
+    this.elements = [];
+    this.elementsById = new Map();
+    this.events = createEventTarget();
+    this.defaultView = null;
+  }
+
+  createElement(tagName) {
+    const element = new FakeElement(this, tagName);
+    this.createdElements.push(element);
+    this.elements.push(element);
+    return element;
+  }
+
+  installElement(id, tagName = "div") {
+    const element = new FakeElement(this, tagName);
+    element.id = id;
+    this.elements.push(element);
+    return element;
+  }
+
+  getElementById(id) {
+    return this.elementsById.get(id) ?? null;
+  }
+
+  addEventListener(...args) {
+    return this.events.addEventListener(...args);
+  }
+
+  removeEventListener(...args) {
+    return this.events.removeEventListener(...args);
+  }
+
+  dispatchEvent(...args) {
+    return this.events.dispatchEvent(...args);
+  }
+
+  listenerCount(type) {
+    return this.events.listenerCount(type);
+  }
+
+  registerId(element) {
+    if (element.id) this.elementsById.set(element.id, element);
+  }
+
+  unregisterId(element) {
+    if (element.id && this.elementsById.get(element.id) === element) {
+      this.elementsById.delete(element.id);
+    }
+  }
+
+  registerTree(element) {
+    this.registerId(element);
+    for (const child of element.children) this.registerTree(child);
+  }
+
+  unregisterTree(element) {
+    this.unregisterId(element);
+    for (const child of element.children) this.unregisterTree(child);
+  }
+}
+
+function toHostValue(value) {
+  if (Array.isArray(value)) return Array.from(value, toHostValue);
+  if (value && typeof value === "object") {
+    if (Object.getPrototypeOf(value) === Object.prototype) return value;
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, toHostValue(entry)]),
+    );
+  }
+  return value;
+}
+
+function boundsForPoints(points) {
+  const pointList = Array.isArray(points?.[0]) ? points : [points];
+  const latitudes = pointList.map(([latitude]) => latitude);
+  const longitudes = pointList.map(([, longitude]) => longitude);
+  const south = Math.min(...latitudes);
+  const west = Math.min(...longitudes);
+  const north = Math.max(...latitudes);
+  const east = Math.max(...longitudes);
+
+  return {
+    south,
+    west,
+    north,
+    east,
+    getSouthWest: () => [south, west],
+    getNorthEast: () => [north, east],
+    toArray: () => [
+      [south, west],
+      [north, east],
+    ],
+  };
+}
+
+function createLeafletRecorder() {
+  const maps = [];
+  const layers = [];
+
+  function createLayer(type, points, options = {}) {
+    const hostPoints = toHostValue(points);
+    const layer = {
+      type,
+      points: hostPoints,
+      latlngs: hostPoints,
+      options: toHostValue(options),
+      map: null,
+      addTo(map) {
+        this.map = map;
+        map.layers.push(this);
+        return this;
+      },
+    };
+
+    if (type === "polyline") {
+      layer.getBounds = () => boundsForPoints(hostPoints);
+    }
+
+    layers.push(layer);
+    return layer;
+  }
+
+  const leaflet = {
+    CRS: { Simple: Object.freeze({ name: "Simple" }) },
+
+    map(container, options = {}) {
+      const map = {
+        container,
+        options: toHostValue(options),
+        layers: [],
+        fitBoundsCalls: [],
+        invalidateSizeCalls: 0,
+        fitBounds(bounds, fitOptions) {
+          this.fitBoundsCalls.push({
+            bounds: Array.isArray(bounds) ? toHostValue(bounds) : bounds,
+            options: toHostValue(fitOptions),
+          });
+          return this;
+        },
+        invalidateSize() {
+          this.invalidateSizeCalls += 1;
+          return this;
+        },
+      };
+      maps.push(map);
+      return map;
+    },
+
+    polyline(points, options) {
+      return createLayer("polyline", points, options);
+    },
+
+    circleMarker(point, options) {
+      return createLayer("circleMarker", point, options);
+    },
+  };
+
+  return { leaflet, maps, layers };
+}
+
+function createConsoleRecorder() {
+  const messages = { debug: [], info: [], log: [], warn: [], error: [] };
+  const console = {};
+
+  for (const method of Object.keys(messages)) {
+    console[method] = (...args) => messages[method].push(args);
+  }
+
+  return { console, messages };
+}
+
+/**
+ * Create an isolated browser-like runtime for the two classic frontend scripts.
+ * The returned object exposes the fake DOM, window, Leaflet recorder, timers,
+ * and event dispatch helpers used by frontend tests.
+ */
+export function createBrowserHarness({
+  directionSteps,
+  routeCoordinates,
+  floorBounds,
+  windowProperties = {},
+  globals = {},
+} = {}) {
+  const document = new FakeDocument();
+  const directionsContainer = document.installElement(
+    "directions-card-container",
+  );
+  const mapContainer = document.installElement("map");
+  const window = createEventTarget();
+  const { leaflet, maps, layers } = createLeafletRecorder();
+  const { console, messages } = createConsoleRecorder();
+  const timers = new Map();
+  let nextTimerId = 1;
+
+  Object.assign(window, {
+    window,
+    self: window,
+    document,
+    L: leaflet,
+    ...windowProperties,
+    ...globals,
+  });
+  if (directionSteps !== undefined) {
+    window.directionSteps = directionSteps;
+  }
+  if (routeCoordinates !== undefined) {
+    window.routeCoordinates = routeCoordinates;
+  }
+  if (floorBounds !== undefined) {
+    window.floorBounds = floorBounds;
+  }
+  document.defaultView = window;
+
+  function setTimeoutFake(callback, delay = 0, ...args) {
+    const id = nextTimerId++;
+    timers.set(id, { callback, delay, args });
+    return id;
+  }
+
+  function clearTimeoutFake(id) {
+    timers.delete(id);
+  }
+
+  function runTimers() {
+    while (timers.size) {
+      const [id, timer] = timers.entries().next().value;
+      timers.delete(id);
+      timer.callback(...timer.args);
+    }
+  }
+
+  const context = vm.createContext({
+    window,
+    document,
+    L: leaflet,
+    console,
+    setTimeout: setTimeoutFake,
+    clearTimeout: clearTimeoutFake,
+    ...windowProperties,
+    ...globals,
+  });
+  if (directionSteps !== undefined) {
+    context.directionSteps = directionSteps;
+  }
+  if (routeCoordinates !== undefined) {
+    context.routeCoordinates = routeCoordinates;
+  }
+  if (floorBounds !== undefined) {
+    context.floorBounds = floorBounds;
+  }
+
+  const harness = {
+    isBrowserHarness: true,
+    context,
+    window,
+    document,
+    L: leaflet,
+    leaflet,
+    console,
+    consoleMessages: messages,
+    directionsContainer,
+    mapContainer,
+    maps,
+    layers,
+    timers,
+    dispatchDOMContentLoaded() {
+      document.dispatchEvent({ type: "DOMContentLoaded" });
+      return harness;
+    },
+    dispatchWindowEvent(eventOrType) {
+      window.dispatchEvent(eventOrType);
+      return harness;
+    },
+    runTimers,
+    flushTimers: runTimers,
+    getElementById(id) {
+      return document.getElementById(id);
+    },
+    getCreatedElements() {
+      return [...document.createdElements];
+    },
+    getCreatedLayers() {
+      return [...layers];
+    },
+  };
+
+  return harness;
+}
+
+function isBrowserHarness(value) {
+  return value?.isBrowserHarness === true;
+}
+
+function resolveScriptPath(scriptPath) {
+  if (scriptPath instanceof URL) return fileURLToPath(scriptPath);
+
+  const value = String(scriptPath);
+  if (
+    value === "directions" ||
+    value === "directions.js" ||
+    value.endsWith("/directions.js")
+  ) {
+    return SCRIPT_PATHS.directions;
+  }
+  if (value === "map" || value === "map.js" || value.endsWith("/map.js")) {
+    return SCRIPT_PATHS.map;
+  }
+
+  const candidates = isAbsolute(value)
+    ? [value]
+    : [resolve(PROJECT_ROOT, value), resolve(FRONTEND_DIR, value)];
+  const path = candidates.find((candidate) => existsSync(candidate));
+  if (!path) {
+    throw new Error(`Frontend script not found: ${scriptPath}`);
+  }
+  return path;
+}
+
+function prepareLoad(scriptOptions) {
+  if (isBrowserHarness(scriptOptions)) {
+    return { harness: scriptOptions, options: {} };
+  }
+
+  const options = scriptOptions ?? {};
+  const harness =
+    options.harness ??
+    createBrowserHarness({
+      directionSteps: options.directionSteps,
+      routeCoordinates: options.routeCoordinates,
+      floorBounds: options.floorBounds,
+      windowProperties: options.windowProperties,
+      globals: options.globals,
+    });
+  return { harness, options };
+}
+
+function applyGlobals(harness, options) {
+  if (options.directionSteps !== undefined) {
+    harness.window.directionSteps = options.directionSteps;
+    harness.context.directionSteps = options.directionSteps;
+  }
+  if (options.routeCoordinates !== undefined) {
+    harness.window.routeCoordinates = options.routeCoordinates;
+    harness.context.routeCoordinates = options.routeCoordinates;
+  }
+  if (options.floorBounds !== undefined) {
+    harness.window.floorBounds = options.floorBounds;
+    harness.context.floorBounds = options.floorBounds;
+  }
+  for (const [name, value] of Object.entries(options.globals ?? {})) {
+    harness.window[name] = value;
+    harness.context[name] = value;
+  }
+}
+
+/**
+ * Evaluate a classic browser script in a fresh or supplied harness.
+ * By default the DOMContentLoaded event and queued fake timers are drained.
+ */
+export function loadScript(scriptPath, scriptOptions = {}) {
+  const { harness, options } = prepareLoad(scriptOptions);
+  applyGlobals(harness, options);
+
+  const resolvedPath = resolveScriptPath(scriptPath);
+  const source = readFileSync(resolvedPath, "utf8");
+  vm.runInContext(source, harness.context, { filename: resolvedPath });
+
+  if (options.dispatchDOMContentLoaded !== false) {
+    harness.dispatchDOMContentLoaded();
+  }
+  if (options.flushTimers !== false) {
+    harness.runTimers();
+  }
+  return harness;
+}
+
+export function loadDirectionsScript(scriptOptions = {}) {
+  return loadScript(SCRIPT_PATHS.directions, scriptOptions);
+}
+
+export function loadMapScript(scriptOptions = {}) {
+  return loadScript(SCRIPT_PATHS.map, scriptOptions);
+}
+
+export function getCreatedElements(harness) {
+  if (!isBrowserHarness(harness)) {
+    throw new TypeError("getCreatedElements expects a browser harness");
+  }
+  return [...harness.document.createdElements];
+}
+
+export function getCreatedLayers(harness) {
+  if (!isBrowserHarness(harness)) {
+    throw new TypeError("getCreatedLayers expects a browser harness");
+  }
+  return [...harness.layers];
+}
+
+export function getMaps(harness) {
+  if (!isBrowserHarness(harness)) {
+    throw new TypeError("getMaps expects a browser harness");
+  }
+  return [...harness.maps];
+}
diff --git a/tests/frontend/map.test.mjs b/tests/frontend/map.test.mjs
new file mode 100644
index 0000000..9d77997
--- /dev/null
+++ b/tests/frontend/map.test.mjs
@@ -0,0 +1,260 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "node:test";
+
+import { loadMapScript } from "./harness.mjs";
+
+const template = readFileSync(
+  new URL("../../app/templates/index.html", import.meta.url),
+  "utf8",
+);
+
+test("map stops with a useful error when template globals are missing", () => {
+  const cases = [
+    {
+      name: "routeCoordinates",
+      options: { floorBounds: { width: 30, height: 20 } },
+    },
+    { name: "floorBounds", options: { routeCoordinates: [{ x: 2, y: 3 }] } },
+  ];
+
+  for (const { name, options } of cases) {
+    const harness = loadMapScript(options);
+
+    assert.equal(harness.maps.length, 0, `${name} should prevent map setup`);
+    assert.equal(
+      harness.layers.length,
+      0,
+      `${name} should prevent layer setup`,
+    );
+    assert.deepEqual(harness.consoleMessages.error, [
+      ["routeCoordinates or floorBounds missing from template"],
+    ]);
+  }
+});
+
+test("map template wires data globals before loading the browser scripts", () => {
+  const directionsDataIndex = template.indexOf("const directionSteps");
+  const directionsScriptIndex = template.indexOf("js/directions.js");
+  const mapDataIndex = template.indexOf("window.routeCoordinates");
+  const mapScriptIndex = template.indexOf("js/map.js");
+
+  assert.match(template, /id="directions-card-container"/);
+  assert.match(
+    template,
+    /const directionSteps\s*=\s*\{\{\s*steps\s*\|\s*tojson/,
+  );
+  assert.match(template, /id="map"/);
+  assert.match(
+    template,
+    /window\.routeCoordinates\s*=\s*\{\{\s*coordinates\s*\|\s*tojson/,
+  );
+  assert.match(
+    template,
+    /window\.floorBounds\s*=\s*\{\{\s*floor_bounds\s*\|\s*tojson/,
+  );
+  assert.ok(directionsDataIndex >= 0);
+  assert.ok(directionsDataIndex < directionsScriptIndex);
+  assert.ok(mapDataIndex >= 0);
+  assert.ok(mapDataIndex < mapScriptIndex);
+});
+
+test("map stops when Leaflet is missing", () => {
+  const harness = loadMapScript({
+    routeCoordinates: [{ x: 2, y: 3, floor: 1 }],
+    floorBounds: { width: 30, height: 20 },
+    globals: { L: undefined },
+  });
+
+  assert.equal(harness.maps.length, 0);
+  assert.deepEqual(harness.consoleMessages.error, [
+    ["Leaflet is missing from the page"],
+  ]);
+});
+
+test("map declines to draw a route that crosses floors", () => {
+  const harness = loadMapScript({
+    routeCoordinates: [
+      { x: 2, y: 3, floor: 1 },
+      { x: 4, y: 5, floor: 2 },
+    ],
+    floorBounds: { width: 30, height: 20 },
+  });
+
+  assert.equal(harness.maps.length, 0);
+  assert.deepEqual(harness.consoleMessages.error, [
+    ["Map preview only supports routes on one floor"],
+  ]);
+});
+
+test("map creates the bounded map without a route for empty coordinates", () => {
+  const harness = loadMapScript({
+    routeCoordinates: [],
+    floorBounds: { width: 30, height: 20 },
+  });
+
+  assert.equal(harness.maps.length, 1);
+  assert.equal(
+    harness.layers.filter((layer) => layer.type === "polyline").length,
+    7,
+  );
+  assert.equal(
+    harness.layers.filter((layer) => layer.type === "circleMarker").length,
+    0,
+  );
+  assert.equal(harness.maps[0].fitBoundsCalls.length, 1);
+});
+
+test("map uses Simple CRS, configured zoom options, and floor bounds", () => {
+  const harness = loadMapScript({
+    routeCoordinates: [
+      { x: 4, y: 2 },
+      { x: 28, y: 18 },
+    ],
+    floorBounds: { width: 30, height: 20 },
+  });
+  const map = harness.maps[0];
+
+  assert.equal(map.container, "map");
+  assert.equal(map.options.crs, harness.L.CRS.Simple);
+  assert.deepEqual(
+    {
+      minZoom: map.options.minZoom,
+      maxZoom: map.options.maxZoom,
+      zoomControl: map.options.zoomControl,
+    },
+    { minZoom: -2, maxZoom: 4, zoomControl: true },
+  );
+  assert.deepEqual(map.fitBoundsCalls[0].bounds, [
+    [0, 0],
+    [20, 30],
+  ]);
+});
+
+test("map draws a 10-foot grid across the floor dimensions", () => {
+  const harness = loadMapScript({
+    routeCoordinates: [{ x: 5, y: 5 }],
+    floorBounds: { width: 30, height: 20 },
+  });
+  const grid = harness.layers.filter(
+    (layer) => layer.type === "polyline" && layer.options.color === "#cccccc",
+  );
+  const map = harness.maps[0];
+
+  assert.deepEqual(
+    grid.map((layer) => layer.points),
+    [
+      [
+        [0, 0],
+        [20, 0],
+      ],
+      [
+        [0, 10],
+        [20, 10],
+      ],
+      [
+        [0, 20],
+        [20, 20],
+      ],
+      [
+        [0, 30],
+        [20, 30],
+      ],
+      [
+        [0, 0],
+        [0, 30],
+      ],
+      [
+        [10, 0],
+        [10, 30],
+      ],
+      [
+        [20, 0],
+        [20, 30],
+      ],
+    ],
+  );
+  assert.equal(grid.length, 7);
+  assert.ok(grid.every((layer) => layer.map === map));
+  assert.ok(
+    grid.every(
+      (layer) => layer.options.weight === 1 && layer.options.opacity === 0.4,
+    ),
+  );
+});
+
+test("map converts backend x/y points and styles the route line", () => {
+  const harness = loadMapScript({
+    routeCoordinates: [
+      { x: 12, y: 4 },
+      { x: 20, y: 15 },
+    ],
+    floorBounds: { width: 30, height: 20 },
+  });
+  const routeLine = harness.layers.find(
+    (layer) =>
+      layer.type === "polyline" && layer.options.className === "animated-route",
+  );
+  const routeFit = harness.maps[0].fitBoundsCalls[1];
+
+  assert.equal(routeLine.map, harness.maps[0]);
+  assert.deepEqual(routeLine.points, [
+    [4, 12],
+    [15, 20],
+  ]);
+  assert.deepEqual(routeLine.options, {
+    color: "blue",
+    weight: 4,
+    dashArray: "10, 10",
+    className: "animated-route",
+  });
+  assert.deepEqual(routeFit.bounds.toArray(), [
+    [4, 12],
+    [15, 20],
+  ]);
+  assert.deepEqual(routeFit.options, { padding: [20, 20] });
+});
+
+test("map marks the route start green and end red", () => {
+  const harness = loadMapScript({
+    routeCoordinates: [
+      { x: 3, y: 7 },
+      { x: 22, y: 11 },
+    ],
+    floorBounds: { width: 30, height: 20 },
+  });
+  const markers = harness.layers.filter(
+    (layer) => layer.type === "circleMarker",
+  );
+
+  assert.equal(markers.length, 2);
+  assert.equal(markers[0].map, harness.maps[0]);
+  assert.deepEqual(markers[0].points, [7, 3]);
+  assert.deepEqual(markers[0].options, {
+    radius: 6,
+    color: "green",
+    fillColor: "green",
+    fillOpacity: 1,
+  });
+  assert.deepEqual(markers[1].points, [11, 22]);
+  assert.deepEqual(markers[1].options, {
+    radius: 6,
+    color: "red",
+    fillColor: "red",
+    fillOpacity: 1,
+  });
+});
+
+test("map invalidates its size on the resize event and deferred startup check", () => {
+  const harness = loadMapScript({
+    routeCoordinates: [{ x: 5, y: 5 }],
+    floorBounds: { width: 30, height: 20 },
+  });
+  const map = harness.maps[0];
+
+  assert.equal(harness.window.listenerCount("resize"), 1);
+  assert.equal(map.invalidateSizeCalls, 1);
+
+  harness.dispatchWindowEvent("resize");
+  assert.equal(map.invalidateSizeCalls, 2);
+});
diff --git a/tests/test_csv_import.py b/tests/test_csv_import.py
new file mode 100644
index 0000000..a2aaa78
--- /dev/null
+++ b/tests/test_csv_import.py
@@ -0,0 +1,187 @@
+import json
+import sys
+
+import pytest
+
+from tools import csv_import
+
+
+def configure_nodes_path(monkeypatch, tmp_path):
+    path = tmp_path / "data" / "nodes.json"
+    monkeypatch.setattr(csv_import, "NODES_PATH", path)
+    return path
+
+
+def test_load_nodes_returns_empty_list_when_file_is_missing(monkeypatch, tmp_path):
+    configure_nodes_path(monkeypatch, tmp_path)
+
+    assert csv_import.load_nodes() == []
+
+
+def test_main_imports_new_nodes_and_skips_duplicates(monkeypatch, tmp_path, capsys):
+    nodes_path = configure_nodes_path(monkeypatch, tmp_path)
+    nodes_path.parent.mkdir()
+    nodes_path.write_text(json.dumps([{"id": "existing", "name": "Existing"}]))
+    csv_path = tmp_path / "rooms.csv"
+    csv_path.write_text(
+        "id,name,building,floor,type\n"
+        "existing,Old Name,BLDG,1,room\n"
+        "# comment,Ignored,BLDG,1,room\n"
+        ",Blank,BLDG,1,room\n"
+        "new,New Room,BLDG,3,room\n"
+        "new,Duplicate,BLDG,4,room\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(sys, "argv", ["csv_import.py", str(csv_path)])
+
+    csv_import.main()
+
+    nodes = json.loads(nodes_path.read_text(encoding="utf-8"))
+    assert nodes == [
+        {"id": "existing", "name": "Existing"},
+        {
+            "id": "new",
+            "name": "New Room",
+            "type": "room",
+            "building": "BLDG",
+            "coords": [0, 0],
+            "floor": 3,
+        },
+    ]
+    output = capsys.readouterr().out
+    assert "SKIP (already exists): existing" in output
+    assert "Done: 1 node(s) added, 2 skipped." in output
+
+
+def test_main_uses_default_csv_path_when_no_argument(monkeypatch, tmp_path):
+    nodes_path = configure_nodes_path(monkeypatch, tmp_path)
+    nodes_path.parent.mkdir()
+    csv_path = tmp_path / "default.csv"
+    csv_path.write_text("id,name,building,floor,type\nroom,Room,BLDG,1,room\n")
+    monkeypatch.setattr(csv_import, "DEFAULT_CSV", csv_path)
+    monkeypatch.setattr(sys, "argv", ["csv_import.py"])
+
+    csv_import.main()
+
+    assert json.loads(nodes_path.read_text(encoding="utf-8"))[0]["id"] == "room"
+
+
+def test_main_ignores_blank_lines_and_comment_or_blank_ids(monkeypatch, tmp_path):
+    nodes_path = configure_nodes_path(monkeypatch, tmp_path)
+    nodes_path.parent.mkdir()
+    csv_path = tmp_path / "rooms.csv"
+    csv_path.write_text(
+        "id,name,building,floor,type\n"
+        "\n"
+        "  # comment,Ignored,BLDG,1,room\n"
+        "   ,No ID,BLDG,1,room\n"
+        "room,Room,BLDG,1,room\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(sys, "argv", ["csv_import.py", str(csv_path)])
+
+    csv_import.main()
+
+    assert json.loads(nodes_path.read_text(encoding="utf-8")) == [
+        {
+            "id": "room",
+            "name": "Room",
+            "type": "room",
+            "building": "BLDG",
+            "coords": [0, 0],
+            "floor": 1,
+        }
+    ]
+
+
+def test_main_strips_node_fields_from_explicit_csv_path(monkeypatch, tmp_path):
+    nodes_path = configure_nodes_path(monkeypatch, tmp_path)
+    nodes_path.parent.mkdir()
+    csv_path = tmp_path / "rooms.csv"
+    csv_path.write_text(
+        "id,name,building,floor,type\n room , Room 101 , BLDG , 2 , classroom \n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(sys, "argv", ["csv_import.py", str(csv_path)])
+
+    csv_import.main()
+
+    assert json.loads(nodes_path.read_text(encoding="utf-8")) == [
+        {
+            "id": "room",
+            "name": "Room 101",
+            "type": "classroom",
+            "building": "BLDG",
+            "coords": [0, 0],
+            "floor": 2,
+        }
+    ]
+
+
+def test_main_uses_defaults_for_missing_csv_columns(monkeypatch, tmp_path):
+    nodes_path = configure_nodes_path(monkeypatch, tmp_path)
+    nodes_path.parent.mkdir()
+    csv_path = tmp_path / "rooms.csv"
+    csv_path.write_text("id\n  room_101  \n", encoding="utf-8")
+    monkeypatch.setattr(sys, "argv", ["csv_import.py", str(csv_path)])
+
+    csv_import.main()
+
+    assert json.loads(nodes_path.read_text(encoding="utf-8")) == [
+        {
+            "id": "room_101",
+            "name": "room_101",
+            "type": "room",
+            "building": "",
+            "coords": [0, 0],
+            "floor": 1,
+        }
+    ]
+
+
+def test_load_nodes_raises_for_malformed_json_without_writing(monkeypatch, tmp_path):
+    nodes_path = configure_nodes_path(monkeypatch, tmp_path)
+    nodes_path.parent.mkdir()
+    malformed = '{"nodes":'
+    nodes_path.write_text(malformed, encoding="utf-8")
+
+    with pytest.raises(json.JSONDecodeError):
+        csv_import.load_nodes()
+
+    assert nodes_path.read_text(encoding="utf-8") == malformed
+
+
+def test_main_does_not_write_partial_import_when_floor_conversion_fails(
+    monkeypatch, tmp_path
+):
+    nodes_path = configure_nodes_path(monkeypatch, tmp_path)
+    nodes_path.parent.mkdir()
+    existing = [{"id": "existing", "name": "Existing"}]
+    nodes_path.write_text(json.dumps(existing), encoding="utf-8")
+    before = nodes_path.read_bytes()
+    csv_path = tmp_path / "rooms.csv"
+    csv_path.write_text(
+        "id,name,building,floor,type\n"
+        "new,New Room,BLDG,2,room\n"
+        "broken,Broken Room,BLDG,not-a-floor,room\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(sys, "argv", ["csv_import.py", str(csv_path)])
+
+    with pytest.raises(ValueError):
+        csv_import.main()
+
+    assert nodes_path.read_bytes() == before
+    assert json.loads(nodes_path.read_text(encoding="utf-8")) == existing
+
+
+def test_main_exits_when_csv_file_is_missing(monkeypatch, tmp_path, capsys):
+    configure_nodes_path(monkeypatch, tmp_path)
+    missing = tmp_path / "missing.csv"
+    monkeypatch.setattr(sys, "argv", ["csv_import.py", str(missing)])
+
+    with pytest.raises(SystemExit) as exc_info:
+        csv_import.main()
+
+    assert exc_info.value.code == 1
+    assert f"CSV file not found: {missing}" in capsys.readouterr().out
diff --git a/tests/test_data_entry.py b/tests/test_data_entry.py
new file mode 100644
index 0000000..4c68f04
--- /dev/null
+++ b/tests/test_data_entry.py
@@ -0,0 +1,163 @@
+import json
+
+import pytest
+
+from app.logic import data_entry
+
+
+def set_data_files(monkeypatch, tmp_path):
+    nodes_file = tmp_path / "nested" / "nodes.json"
+    edges_file = tmp_path / "nested" / "edges.json"
+    monkeypatch.setattr(data_entry, "NODES_FILE", nodes_file)
+    monkeypatch.setattr(data_entry, "EDGES_FILE", edges_file)
+    return nodes_file, edges_file
+
+
+def test_load_json_returns_empty_list_for_missing_file(tmp_path):
+    assert data_entry.load_json(tmp_path / "missing.json") == []
+
+
+def test_load_json_reads_data_and_reports_malformed_json(tmp_path, capsys):
+    path = tmp_path / "data.json"
+    path.write_text('{"valid": true}', encoding="utf-8")
+    assert data_entry.load_json(path) == {"valid": True}
+
+    path.write_text("not json", encoding="utf-8")
+    with pytest.raises(json.JSONDecodeError):
+        data_entry.load_json(path)
+    assert "Failed to parse JSON file" in capsys.readouterr().out
+
+
+def test_save_json_creates_parent_and_round_trips_data(tmp_path):
+    path = tmp_path / "new" / "data.json"
+    expected = [{"id": "room"}]
+
+    data_entry.save_json(path, expected)
+
+    assert json.loads(path.read_text(encoding="utf-8")) == expected
+
+
+def test_default_paths_point_to_repository_data_directory():
+    repo_root = data_entry.BASE_DIR.parents[1]
+
+    assert data_entry.DATA_DIR == repo_root / "data"
+    assert data_entry.NODES_FILE == repo_root / "data" / "nodes.json"
+    assert data_entry.EDGES_FILE == repo_root / "data" / "edges.json"
+
+
+def test_add_node_rejects_duplicate_without_prompting_for_details(
+    monkeypatch, tmp_path, capsys
+):
+    nodes_file, _ = set_data_files(monkeypatch, tmp_path)
+    existing = [{"id": "room", "name": "Existing"}]
+    data_entry.save_json(nodes_file, existing)
+    input_values = iter(["room"])
+    monkeypatch.setattr("builtins.input", lambda _prompt: next(input_values))
+
+    data_entry.add_node()
+
+    assert data_entry.load_json(nodes_file) == existing
+    assert "already exists" in capsys.readouterr().out
+
+
+def test_add_node_saves_normalized_values(monkeypatch, tmp_path):
+    nodes_file, _ = set_data_files(monkeypatch, tmp_path)
+    input_values = iter([" room ", "12.5", "-3", " Room 101 ", " room ", "4"])
+    monkeypatch.setattr("builtins.input", lambda _prompt: next(input_values))
+
+    data_entry.add_node()
+
+    assert data_entry.load_json(nodes_file) == [
+        {
+            "id": "room",
+            "name": "Room 101",
+            "type": "room",
+            "building": "NPB",
+            "coords": [12.5, -3.0],
+            "floor": 4,
+        }
+    ]
+
+
+@pytest.mark.parametrize(
+    ("invalid_input_index", "invalid_value"),
+    [(1, "not-a-number"), (2, "not-a-number"), (5, "not-a-floor")],
+)
+def test_add_node_does_not_write_when_numeric_input_is_invalid(
+    monkeypatch, tmp_path, invalid_input_index, invalid_value
+):
+    nodes_file, _ = set_data_files(monkeypatch, tmp_path)
+    existing = [{"id": "existing", "name": "Existing"}]
+    data_entry.save_json(nodes_file, existing)
+    before = nodes_file.read_bytes()
+    values = ["new", "1", "2", "New room", "room", "1"]
+    values[invalid_input_index] = invalid_value
+    input_values = iter(values)
+    monkeypatch.setattr("builtins.input", lambda _prompt: next(input_values))
+
+    with pytest.raises(ValueError):
+        data_entry.add_node()
+
+    assert nodes_file.read_bytes() == before
+    assert data_entry.load_json(nodes_file) == existing
+
+
+def test_add_edge_rejects_unknown_nodes(monkeypatch, tmp_path, capsys):
+    nodes_file, edges_file = set_data_files(monkeypatch, tmp_path)
+    data_entry.save_json(nodes_file, [{"id": "known"}])
+    input_values = iter(["known", "missing", "2", "Go there"])
+    monkeypatch.setattr("builtins.input", lambda _prompt: next(input_values))
+
+    data_entry.add_edge()
+
+    assert not edges_file.exists()
+    assert "missing" in capsys.readouterr().out
+
+
+def test_add_edge_saves_valid_connection(monkeypatch, tmp_path):
+    nodes_file, edges_file = set_data_files(monkeypatch, tmp_path)
+    data_entry.save_json(nodes_file, [{"id": "a"}, {"id": "b"}])
+    input_values = iter([" a ", " b ", "2.5", " Turn right. "])
+    monkeypatch.setattr("builtins.input", lambda _prompt: next(input_values))
+
+    data_entry.add_edge()
+
+    assert data_entry.load_json(edges_file) == [
+        {
+            "source": "a",
+            "target": "b",
+            "weight": 2.5,
+            "instruction": "Turn right.",
+        }
+    ]
+
+
+def test_add_edge_reports_all_unknown_endpoints_without_writing(
+    monkeypatch, tmp_path, capsys
+):
+    nodes_file, edges_file = set_data_files(monkeypatch, tmp_path)
+    data_entry.save_json(nodes_file, [{"id": "known"}])
+    existing_edges = [{"source": "known", "target": "known", "weight": 1}]
+    data_entry.save_json(edges_file, existing_edges)
+    before = edges_file.read_bytes()
+    input_values = iter(["missing-start", "missing-end", "2", "Go there"])
+    monkeypatch.setattr("builtins.input", lambda _prompt: next(input_values))
+
+    data_entry.add_edge()
+
+    assert edges_file.read_bytes() == before
+    assert data_entry.load_json(edges_file) == existing_edges
+    output = capsys.readouterr().out
+    assert "missing-start" in output
+    assert "missing-end" in output
+
+
+def test_main_reports_invalid_choice_then_exits(monkeypatch, capsys):
+    input_values = iter(["not-an-option", "3"])
+    monkeypatch.setattr("builtins.input", lambda _prompt: next(input_values))
+
+    data_entry.main()
+
+    output = capsys.readouterr().out
+    assert "Invalid option" in output
+    assert "Exiting..." in output
diff --git a/tests/test_data_integrity.py b/tests/test_data_integrity.py
new file mode 100644
index 0000000..e94c1ee
--- /dev/null
+++ b/tests/test_data_integrity.py
@@ -0,0 +1,152 @@
+import csv
+import json
+from pathlib import Path
+
+from tools import generate_vertical_edges, validate_data
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+NODES_PATH = REPO_ROOT / "data" / "nodes.json"
+EDGES_PATH = REPO_ROOT / "data" / "edges.json"
+FLOORS_PATH = REPO_ROOT / "data" / "floors.json"
+ROOMS_CSV_PATH = REPO_ROOT / "tools" / "npb_rooms.csv"
+
+NODE_FIELDS = {"id", "name", "type", "building", "floor", "coords"}
+EDGE_FIELDS = {"source", "target", "weight", "instruction"}
+FLOOR_FIELDS = {
+    "width_feet",
+    "height_feet",
+    "px_per_foot",
+    "origin_px",
+}
+ROOMS_CSV_FIELDS = ["id", "name", "building", "floor", "type"]
+
+
+def read_json(path):
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def is_number(value):
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def test_canonical_data_has_consistent_schemas_and_is_not_mutated(capsys):
+    paths = [NODES_PATH, EDGES_PATH, FLOORS_PATH, ROOMS_CSV_PATH]
+    before = {path: path.read_bytes() for path in paths}
+
+    nodes = read_json(NODES_PATH)
+    edges = read_json(EDGES_PATH)
+    floors = read_json(FLOORS_PATH)
+
+    assert isinstance(nodes, list) and nodes
+    assert isinstance(edges, list) and edges
+    assert isinstance(floors, dict) and floors
+
+    node_ids = set()
+    for node in nodes:
+        assert set(node) == NODE_FIELDS
+        assert isinstance(node["id"], str) and node["id"]
+        assert node["id"] not in node_ids
+        node_ids.add(node["id"])
+        assert isinstance(node["name"], str) and node["name"].strip()
+        assert isinstance(node["type"], str) and node["type"].strip()
+        assert isinstance(node["building"], str) and node["building"].strip()
+        assert isinstance(node["floor"], int) and not isinstance(node["floor"], bool)
+        assert node["id"].startswith(f"{node['building']}_{node['floor']}_")
+        assert (
+            isinstance(node["coords"], list)
+            and len(node["coords"]) == 2
+            and all(is_number(value) for value in node["coords"])
+        )
+
+    edge_pairs = set()
+    for edge in edges:
+        assert set(edge) == EDGE_FIELDS
+        assert edge["source"] in node_ids
+        assert edge["target"] in node_ids
+        assert is_number(edge["weight"])
+        assert isinstance(edge["instruction"], str)
+        assert edge["instruction"].strip()
+        edge_pairs.add((edge["source"], edge["target"]))
+
+    assert len(edge_pairs) == len(edges)
+    assert all((target, source) in edge_pairs for source, target in edge_pairs)
+
+    assert set(floors) == {"NPB"}
+    assert set(floors["NPB"]) == {"1", "2", "3", "4", "5"}
+    for floor in floors["NPB"].values():
+        assert set(floor) == FLOOR_FIELDS
+        assert is_number(floor["width_feet"]) and floor["width_feet"] > 0
+        assert is_number(floor["height_feet"]) and floor["height_feet"] > 0
+        if floor["px_per_foot"] is None:
+            assert floor["origin_px"] is None
+        else:
+            assert is_number(floor["px_per_foot"]) and floor["px_per_foot"] > 0
+            assert (
+                isinstance(floor["origin_px"], list)
+                and len(floor["origin_px"]) == 2
+                and all(is_number(value) for value in floor["origin_px"])
+            )
+
+    with ROOMS_CSV_PATH.open(newline="", encoding="utf-8") as file:
+        reader = csv.DictReader(file)
+        assert reader.fieldnames == ROOMS_CSV_FIELDS
+        rows = list(reader)
+
+    assert rows
+    room_ids = set()
+    for row in rows:
+        assert set(row) == set(ROOMS_CSV_FIELDS)
+        assert all(isinstance(value, str) and value.strip() for value in row.values())
+        assert row["id"] not in room_ids
+        room_ids.add(row["id"])
+        assert row["building"] == "NPB"
+        floor = int(row["floor"])
+        assert str(floor) in floors["NPB"]
+        assert row["id"].startswith(f"{row['building']}_{floor}_")
+
+    # The validator reports the canonical JSON without writing any of it.
+    validate_data.main()
+    assert "Data OK — 277 nodes, 580 edges (580 connections)" in capsys.readouterr().out
+
+    assert {path: path.read_bytes() for path in paths} == before
+
+
+def test_canonical_vertical_connections_are_present_in_edges():
+    nodes = read_json(NODES_PATH)
+    edges = read_json(EDGES_PATH)
+    connectors = generate_vertical_edges.discover_connectors(nodes)
+    generated = generate_vertical_edges.generate_edges(connectors)
+    persisted = {
+        (edge["source"], edge["target"], edge["weight"], edge["instruction"])
+        for edge in edges
+    }
+
+    assert set(connectors) == {
+        ("NPB", "E1"),
+        ("NPB", "E3"),
+        ("NPB", "S1"),
+        ("NPB", "S2"),
+        ("NPB", "stairs_main"),
+    }
+    assert all(info["floors"] == [3, 4, 5] for info in connectors.values())
+    assert len(generated) == 24
+    assert all(
+        (edge["source"], edge["target"], edge["weight"], edge["instruction"])
+        in persisted
+        for edge in generated
+    )
+
+    # This independent count makes the elevator/stair rules explicit for the
+    # checked-in three-floor dataset: 3 elevators x 6 directed pairs and 3
+    # staircases x 4 directed adjacent pairs.
+    assert len([edge for edge in generated if "_E" in edge["source"]]) == 12
+    assert (
+        len(
+            [
+                edge
+                for edge in generated
+                if "_S" in edge["source"] or "stairs_main" in edge["source"]
+            ]
+        )
+        == 12
+    )
diff --git a/tests/test_generate_vertical_edges.py b/tests/test_generate_vertical_edges.py
new file mode 100644
index 0000000..8b6eabe
--- /dev/null
+++ b/tests/test_generate_vertical_edges.py
@@ -0,0 +1,408 @@
+import json
+
+import pytest
+
+from tools import generate_vertical_edges as generator
+
+
+def test_load_json_returns_empty_list_when_missing(tmp_path):
+    assert generator.load_json(tmp_path / "missing.json") == []
+
+
+def test_load_json_propagates_malformed_json(tmp_path):
+    path = tmp_path / "broken.json"
+    path.write_text("{", encoding="utf-8")
+
+    with pytest.raises(json.JSONDecodeError):
+        generator.load_json(path)
+
+
+def test_save_json_creates_expected_json(tmp_path):
+    path = tmp_path / "nested" / "edges.json"
+    data = [{"source": "a", "target": "b"}]
+
+    path.parent.mkdir()
+    generator.save_json(path, data)
+
+    assert json.loads(path.read_text(encoding="utf-8")) == data
+
+
+def test_save_json_propagates_persistence_failure():
+    class BrokenPath:
+        def open(self, *args, **kwargs):
+            raise OSError("disk full")
+
+    with pytest.raises(OSError, match="disk full"):
+        generator.save_json(BrokenPath(), [])
+
+
+def test_discover_connectors_keys_by_building_and_deduplicates_floors():
+    nodes = [
+        {"id": "BLDG_5_E1", "floor": 5, "name": "E1", "building": "BLDG"},
+        {"id": "BLDG_3_E1", "floor": 3, "name": "E1", "building": "BLDG"},
+        {
+            "id": "BLDG_4_stairs_main",
+            "floor": 4,
+            "name": "Main Stairs",
+            "building": "BLDG",
+        },
+        {
+            "id": "BLDG_2_stairs_main",
+            "floor": 2,
+            "name": "Main Stairs",
+            "building": "BLDG",
+        },
+        {
+            "id": "BLDG_4_stairs_main",
+            "floor": 4,
+            "name": "Main Stairs",
+            "building": "BLDG",
+        },
+        {"id": "SCI_1_S1", "floor": 1, "name": "S1", "building": "SCI"},
+        {"id": "BLDG_2_E2", "floor": 2, "name": "Unknown", "building": "BLDG"},
+        {"id": "short", "floor": 1, "name": "Short", "building": "BLDG"},
+    ]
+
+    connectors = generator.discover_connectors(nodes)
+
+    assert connectors == {
+        ("BLDG", "E1"): {
+            "type": "elevator",
+            "floors": [3, 5],
+            "name": "E1",
+            "building": "BLDG",
+        },
+        ("BLDG", "stairs_main"): {
+            "type": "staircase",
+            "floors": [2, 4],
+            "name": "Main Stairs",
+            "building": "BLDG",
+        },
+        ("SCI", "S1"): {
+            "type": "staircase",
+            "floors": [1],
+            "name": "S1",
+            "building": "SCI",
+        },
+    }
+
+
+def test_discover_connectors_keeps_same_suffixes_in_separate_buildings():
+    nodes = [
+        {"id": "BLDG_1_E1", "floor": 1, "name": "BLDG E1", "building": "BLDG"},
+        {"id": "BLDG_2_E1", "floor": 2, "name": "BLDG E1", "building": "BLDG"},
+        {"id": "SCI_1_E1", "floor": 1, "name": "SCI E1", "building": "SCI"},
+        {"id": "SCI_2_E1", "floor": 2, "name": "SCI E1", "building": "SCI"},
+    ]
+
+    connectors = generator.discover_connectors(nodes)
+
+    assert set(connectors) == {("BLDG", "E1"), ("SCI", "E1")}
+    assert {
+        (edge["source"], edge["target"])
+        for edge in generator.generate_edges(connectors)
+    } == {
+        ("BLDG_1_E1", "BLDG_2_E1"),
+        ("BLDG_2_E1", "BLDG_1_E1"),
+        ("SCI_1_E1", "SCI_2_E1"),
+        ("SCI_2_E1", "SCI_1_E1"),
+    }
+
+
+def test_discover_connectors_uses_building_from_id_when_field_is_missing():
+    nodes = [{"id": "NPB_2_E3", "floor": 2, "name": "E3"}]
+
+    assert generator.discover_connectors(nodes)[("NPB", "E3")]["building"] == "NPB"
+
+
+def test_discover_connectors_rejects_building_id_mismatch():
+    nodes = [{"id": "NPB_2_E3", "floor": 2, "name": "E3", "building": "SCI"}]
+
+    with pytest.raises(ValueError, match="has building 'SCI'.*ID uses 'NPB'"):
+        generator.discover_connectors(nodes)
+
+
+def test_generate_edges_deduplicates_elevator_floors_without_self_edges():
+    connectors = {
+        ("NPB", "E1"): {
+            "type": "elevator",
+            "floors": [1, 2, 2],
+            "name": "E1",
+            "building": "NPB",
+        }
+    }
+
+    edges = generator.generate_edges(connectors)
+
+    assert {(edge["source"], edge["target"]) for edge in edges} == {
+        ("NPB_1_E1", "NPB_2_E1"),
+        ("NPB_2_E1", "NPB_1_E1"),
+    }
+
+
+def test_generate_edges_uses_all_elevator_pairs_but_only_adjacent_stairs():
+    connectors = {
+        "E1": {
+            "type": "elevator",
+            "floors": [1, 3, 5],
+            "name": "E1",
+            "building": "BLDG",
+        },
+        "S1": {
+            "type": "staircase",
+            "floors": [1, 2, 4],
+            "name": "S1",
+            "building": "BLDG",
+        },
+    }
+
+    edges = generator.generate_edges(connectors)
+
+    assert len(edges) == 8
+    assert {
+        (edge["source"], edge["target"]) for edge in edges if "E1" in edge["source"]
+    } == {
+        ("BLDG_1_E1", "BLDG_3_E1"),
+        ("BLDG_3_E1", "BLDG_1_E1"),
+        ("BLDG_1_E1", "BLDG_5_E1"),
+        ("BLDG_5_E1", "BLDG_1_E1"),
+        ("BLDG_3_E1", "BLDG_5_E1"),
+        ("BLDG_5_E1", "BLDG_3_E1"),
+    }
+    stairs = [edge for edge in edges if "S1" in edge["source"]]
+    assert {(edge["source"], edge["target"]) for edge in stairs} == {
+        ("BLDG_1_S1", "BLDG_2_S1"),
+        ("BLDG_2_S1", "BLDG_1_S1"),
+    }
+
+    elevator_up = next(
+        edge
+        for edge in edges
+        if edge["source"] == "BLDG_1_E1" and edge["target"] == "BLDG_5_E1"
+    )
+    assert elevator_up == {
+        "source": "BLDG_1_E1",
+        "target": "BLDG_5_E1",
+        "weight": 80,
+        "instruction": "Take elevator E1 to floor 5.",
+    }
+    assert next(
+        edge
+        for edge in edges
+        if edge["source"] == "BLDG_5_E1" and edge["target"] == "BLDG_1_E1"
+    ) == {
+        "source": "BLDG_5_E1",
+        "target": "BLDG_1_E1",
+        "weight": 80,
+        "instruction": "Take elevator E1 to floor 1.",
+    }
+    assert next(edge for edge in edges if edge["source"] == "BLDG_1_S1") == {
+        "source": "BLDG_1_S1",
+        "target": "BLDG_2_S1",
+        "weight": 20,
+        "instruction": "Take the stairs to floor 2.",
+    }
+    assert next(edge for edge in edges if edge["source"] == "BLDG_2_S1") == {
+        "source": "BLDG_2_S1",
+        "target": "BLDG_1_S1",
+        "weight": 20,
+        "instruction": "Take the stairs to floor 1.",
+    }
+
+
+def test_generate_edges_ignores_stair_gaps_and_duplicate_floors():
+    connectors = {
+        "stairs_main": {
+            "type": "staircase",
+            "floors": [1, 2, 2, 4],
+            "name": "Main Stairs",
+            "building": "NPB",
+        }
+    }
+
+    edges = generator.generate_edges(connectors)
+
+    assert {(edge["source"], edge["target"]) for edge in edges} == {
+        ("NPB_1_stairs_main", "NPB_2_stairs_main"),
+        ("NPB_2_stairs_main", "NPB_1_stairs_main"),
+    }
+    assert all(edge["source"] != edge["target"] for edge in edges)
+
+
+def test_generate_edges_returns_no_edges_without_connectors():
+    assert generator.generate_edges({}) == []
+
+
+def test_main_appends_only_new_vertical_edges(monkeypatch, tmp_path, capsys):
+    nodes_path = tmp_path / "nodes.json"
+    edges_path = tmp_path / "edges.json"
+    nodes = [
+        {"id": "BLDG_1_E1", "floor": 1, "name": "E1", "building": "BLDG"},
+        {"id": "BLDG_2_E1", "floor": 2, "name": "E1", "building": "BLDG"},
+    ]
+    existing = [
+        {
+            "source": "BLDG_1_E1",
+            "target": "BLDG_2_E1",
+            "weight": 20,
+            "instruction": "Existing",
+        }
+    ]
+    nodes_path.write_text(json.dumps(nodes), encoding="utf-8")
+    edges_path.write_text(json.dumps(existing), encoding="utf-8")
+    monkeypatch.setattr(generator, "NODES_PATH", nodes_path)
+    monkeypatch.setattr(generator, "EDGES_PATH", edges_path)
+
+    generator.main()
+
+    assert json.loads(edges_path.read_text(encoding="utf-8")) == existing + [
+        {
+            "source": "BLDG_2_E1",
+            "target": "BLDG_1_E1",
+            "weight": 20,
+            "instruction": "Take elevator E1 to floor 1.",
+        }
+    ]
+    assert "1 edge(s) added, 1 skipped" in capsys.readouterr().out
+
+
+def test_main_is_idempotent_when_run_twice(monkeypatch, tmp_path, capsys):
+    nodes_path = tmp_path / "nodes.json"
+    edges_path = tmp_path / "edges.json"
+    nodes_path.write_text(
+        json.dumps(
+            [
+                {
+                    "id": "BLDG_1_E1",
+                    "floor": 1,
+                    "name": "E1",
+                    "building": "BLDG",
+                },
+                {
+                    "id": "BLDG_2_E1",
+                    "floor": 2,
+                    "name": "E1",
+                    "building": "BLDG",
+                },
+            ]
+        ),
+        encoding="utf-8",
+    )
+    edges_path.write_text("[]", encoding="utf-8")
+    monkeypatch.setattr(generator, "NODES_PATH", nodes_path)
+    monkeypatch.setattr(generator, "EDGES_PATH", edges_path)
+
+    generator.main()
+    first_run = json.loads(edges_path.read_text(encoding="utf-8"))
+    generator.main()
+    second_run = json.loads(edges_path.read_text(encoding="utf-8"))
+
+    assert len(first_run) == len(second_run) == 2
+    assert second_run == first_run
+    output = capsys.readouterr().out
+    assert "Done: 2 edge(s) added, 0 skipped." in output
+    assert "Done: 0 edge(s) added, 2 skipped." in output
+
+
+def test_main_does_not_write_when_no_connectors_are_found(
+    monkeypatch, tmp_path, capsys
+):
+    nodes_path = tmp_path / "nodes.json"
+    edges_path = tmp_path / "edges.json"
+    nodes_path.write_text(
+        json.dumps([{"id": "BLDG_2_E2", "floor": 2, "name": "Unknown"}]),
+        encoding="utf-8",
+    )
+    original_edges = [{"source": "a", "target": "b"}]
+    edges_path.write_text(json.dumps(original_edges), encoding="utf-8")
+    monkeypatch.setattr(generator, "NODES_PATH", nodes_path)
+    monkeypatch.setattr(generator, "EDGES_PATH", edges_path)
+    monkeypatch.setattr(
+        generator,
+        "save_json",
+        lambda *_args: pytest.fail("save_json should not run without connectors"),
+    )
+
+    generator.main()
+
+    assert json.loads(edges_path.read_text(encoding="utf-8")) == original_edges
+    assert "No connectors found in nodes.json" in capsys.readouterr().out
+
+
+def test_main_treats_missing_edges_file_as_empty(monkeypatch, tmp_path):
+    nodes_path = tmp_path / "nodes.json"
+    edges_path = tmp_path / "missing-edges.json"
+    nodes_path.write_text(
+        json.dumps(
+            [
+                {
+                    "id": "BLDG_1_E1",
+                    "floor": 1,
+                    "name": "E1",
+                    "building": "BLDG",
+                },
+                {
+                    "id": "BLDG_2_E1",
+                    "floor": 2,
+                    "name": "E1",
+                    "building": "BLDG",
+                },
+            ]
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(generator, "NODES_PATH", nodes_path)
+    monkeypatch.setattr(generator, "EDGES_PATH", edges_path)
+
+    generator.main()
+
+    assert len(json.loads(edges_path.read_text(encoding="utf-8"))) == 2
+
+
+def test_main_handles_missing_input_files_without_creating_edges_file(
+    monkeypatch, tmp_path, capsys
+):
+    nodes_path = tmp_path / "missing-nodes.json"
+    edges_path = tmp_path / "missing-edges.json"
+    monkeypatch.setattr(generator, "NODES_PATH", nodes_path)
+    monkeypatch.setattr(generator, "EDGES_PATH", edges_path)
+
+    generator.main()
+
+    assert not edges_path.exists()
+    assert "No connectors found in nodes.json" in capsys.readouterr().out
+
+
+def test_main_propagates_edges_persistence_failure(monkeypatch, tmp_path):
+    nodes_path = tmp_path / "nodes.json"
+    edges_path = tmp_path / "edges.json"
+    nodes_path.write_text(
+        json.dumps(
+            [
+                {
+                    "id": "BLDG_1_E1",
+                    "floor": 1,
+                    "name": "E1",
+                    "building": "BLDG",
+                },
+                {
+                    "id": "BLDG_2_E1",
+                    "floor": 2,
+                    "name": "E1",
+                    "building": "BLDG",
+                },
+            ]
+        ),
+        encoding="utf-8",
+    )
+    edges_path.write_text("[]", encoding="utf-8")
+    monkeypatch.setattr(generator, "NODES_PATH", nodes_path)
+    monkeypatch.setattr(generator, "EDGES_PATH", edges_path)
+
+    def fail_to_save(*_args):
+        raise OSError("cannot write edges")
+
+    monkeypatch.setattr(generator, "save_json", fail_to_save)
+
+    with pytest.raises(OSError, match="cannot write edges"):
+        generator.main()
diff --git a/tests/test_graph_manager.py b/tests/test_graph_manager.py
new file mode 100644
index 0000000..04e81a2
--- /dev/null
+++ b/tests/test_graph_manager.py
@@ -0,0 +1,397 @@
+import json
+
+import networkx as nx
+import pytest
+
+from app import logic
+from app.logic import graph_manager as manager
+
+
+@pytest.fixture(autouse=True)
+def reset_global_graph():
+    manager.G = None
+    yield
+    manager.G = None
+
+
+def configure_data_root(monkeypatch, tmp_path):
+    repo_root = tmp_path / "repo"
+    logic_path = repo_root / "app" / "logic"
+    data_path = repo_root / "data"
+    logic_path.mkdir(parents=True)
+    data_path.mkdir()
+    monkeypatch.setattr(manager, "__file__", str(logic_path / "graph_manager.py"))
+    return data_path
+
+
+def write_json(path, value):
+    path.write_text(json.dumps(value), encoding="utf-8")
+
+
+def make_graph(*nodes, edges=()):
+    graph = nx.DiGraph()
+    for node_id, attributes in nodes:
+        graph.add_node(node_id, **attributes)
+    for source, target, attributes in edges:
+        graph.add_edge(source, target, **attributes)
+    return graph
+
+
+def node(floor=1, node_type="waypoint", x=0, y=0, name="Node"):
+    return {"floor": floor, "type": node_type, "coords": [x, y], "name": name}
+
+
+def test_read_json_files_loads_nodes_and_edges(monkeypatch, tmp_path):
+    data_path = configure_data_root(monkeypatch, tmp_path)
+    nodes = [{"id": "a", "type": "room"}]
+    edges = [{"source": "a", "target": "a", "weight": 0}]
+    write_json(data_path / "nodes.json", nodes)
+    write_json(data_path / "edges.json", edges)
+
+    assert manager.read_json_files() == (nodes, edges)
+
+
+@pytest.mark.parametrize(
+    ("missing_file", "message"),
+    [
+        ("nodes.json", "Failed to load nodes data"),
+        ("edges.json", "Failed to load edges data"),
+    ],
+)
+def test_read_json_files_reports_missing_data(
+    monkeypatch, tmp_path, missing_file, message
+):
+    data_path = configure_data_root(monkeypatch, tmp_path)
+    write_json(data_path / "nodes.json", [])
+    write_json(data_path / "edges.json", [])
+    (data_path / missing_file).unlink()
+
+    with pytest.raises(RuntimeError, match=message):
+        manager.read_json_files()
+
+
+@pytest.mark.parametrize(
+    ("invalid_file", "message"),
+    [
+        ("nodes.json", "Failed to load nodes data"),
+        ("edges.json", "Failed to load edges data"),
+    ],
+)
+def test_read_json_files_reports_invalid_json(
+    monkeypatch, tmp_path, invalid_file, message
+):
+    data_path = configure_data_root(monkeypatch, tmp_path)
+    write_json(data_path / "nodes.json", [])
+    write_json(data_path / "edges.json", [])
+    (data_path / invalid_file).write_text("not json", encoding="utf-8")
+
+    with pytest.raises(RuntimeError, match=message):
+        manager.read_json_files()
+
+
+def test_read_json_files_uses_module_path_instead_of_working_directory(
+    monkeypatch, tmp_path
+):
+    data_path = configure_data_root(monkeypatch, tmp_path)
+    nodes = [{"id": "from-module-path"}]
+    edges = [{"source": "from-module-path", "target": "from-module-path"}]
+    write_json(data_path / "nodes.json", nodes)
+    write_json(data_path / "edges.json", edges)
+    other_directory = tmp_path / "unrelated-working-directory"
+    other_directory.mkdir()
+    monkeypatch.chdir(other_directory)
+
+    assert manager.read_json_files() == (nodes, edges)
+
+
+def test_build_graph_preserves_node_and_edge_data(monkeypatch):
+    nodes = [
+        {"id": "a", "name": "A", "floor": 1},
+        {"id": "b", "name": "B", "floor": 2},
+    ]
+    edges = [{"source": "a", "target": "b", "weight": 4, "instruction": "Go up."}]
+    monkeypatch.setattr(manager, "read_json_files", lambda: (nodes, edges))
+
+    graph = manager.build_graph()
+
+    assert isinstance(graph, nx.DiGraph)
+    assert graph.nodes["a"] == nodes[0]
+    assert graph["a"]["b"] == edges[0]
+    assert not graph.has_edge("b", "a")
+
+
+def test_reload_graph_replaces_cached_graph(monkeypatch):
+    graph = nx.DiGraph()
+    monkeypatch.setattr(manager, "build_graph", lambda: graph)
+
+    manager.reload_graph()
+
+    assert manager.G is graph
+
+
+def test_shortest_route_uses_edge_weights_and_handles_missing_routes():
+    graph = nx.DiGraph()
+    graph.add_weighted_edges_from(
+        [("start", "direct", 10), ("start", "detour", 2), ("detour", "direct", 3)]
+    )
+
+    assert manager.shortest_route(graph, "start", "direct") == [
+        "start",
+        "detour",
+        "direct",
+    ]
+    assert manager.shortest_route(graph, "direct", "start") is None
+    assert manager.shortest_route(graph, "unknown", "start") is None
+
+
+def test_shortest_route_returns_the_start_node_for_same_node_routes():
+    graph = nx.DiGraph()
+    graph.add_node("room")
+
+    assert manager.shortest_route(graph, "room", "room") == ["room"]
+
+
+def test_get_floor_bounds_reads_dimensions(monkeypatch, tmp_path):
+    data_path = configure_data_root(monkeypatch, tmp_path)
+    write_json(
+        data_path / "floors.json",
+        {"BLDG": {"2": {"width_feet": 120, "height_feet": 80}}},
+    )
+
+    assert manager.get_floor_bounds("BLDG", 2) == {"width": 120, "height": 80}
+
+
+@pytest.mark.parametrize(
+    ("floors_data", "building", "floor", "message"),
+    [
+        ({"BLDG": {}}, "BLDG", 2, "No floor data for BLDG floor 2"),
+        ({}, "BLDG", 2, "No floor data for BLDG floor 2"),
+    ],
+)
+def test_get_floor_bounds_rejects_unknown_floor(
+    monkeypatch, tmp_path, floors_data, building, floor, message
+):
+    data_path = configure_data_root(monkeypatch, tmp_path)
+    write_json(data_path / "floors.json", floors_data)
+
+    with pytest.raises(RuntimeError, match=message):
+        manager.get_floor_bounds(building, floor)
+
+
+def test_get_floor_bounds_reports_invalid_json(monkeypatch, tmp_path):
+    data_path = configure_data_root(monkeypatch, tmp_path)
+    (data_path / "floors.json").write_text("not json", encoding="utf-8")
+
+    with pytest.raises(RuntimeError, match="Failed to load floors data"):
+        manager.get_floor_bounds("BLDG", 1)
+
+
+def test_get_floor_bounds_reports_missing_file(monkeypatch, tmp_path):
+    configure_data_root(monkeypatch, tmp_path)
+
+    with pytest.raises(RuntimeError, match="Failed to load floors data"):
+        manager.get_floor_bounds("BLDG", 1)
+
+
+def test_get_options_separates_connectors_and_rooms(monkeypatch):
+    nodes = [
+        {"id": "e", "name": "Elevator", "type": "elevator"},
+        {"id": "s", "name": "Stairs", "type": "staircase"},
+        {"id": "r", "name": "Room", "type": "room"},
+        {"id": "w", "name": "Waypoint", "type": "waypoint"},
+    ]
+    monkeypatch.setattr(manager, "read_json_files", lambda: (nodes, []))
+
+    entrances, classrooms = manager.get_options()
+
+    assert entrances == [
+        {"id": "e", "name": "Elevator"},
+        {"id": "s", "name": "Stairs"},
+    ]
+    assert classrooms == [{"id": "r", "name": "Room"}]
+
+
+def test_get_directions_returns_instructions_and_route_coordinates():
+    manager.G = make_graph(
+        ("start", node(floor=1, x=1, y=2)),
+        ("middle", node(floor=1, x=3, y=4)),
+        ("end", node(floor=1, x=5, y=6)),
+        edges=[
+            ("start", "middle", {"weight": 1, "instruction": "Walk ahead."}),
+            ("middle", "end", {"weight": 1, "instruction": "Turn right."}),
+        ],
+    )
+
+    result = manager.get_directions("start", "end")
+
+    assert result == {
+        "directions": ["Walk ahead.", "Turn right."],
+        "coordinates": [
+            {"x": 1, "y": 2, "floor": 1},
+            {"x": 3, "y": 4, "floor": 1},
+            {"x": 5, "y": 6, "floor": 1},
+        ],
+    }
+
+
+def test_get_directions_handles_same_start_and_destination():
+    manager.G = make_graph(("room", node(floor=5, x=12, y=-3)))
+
+    assert manager.get_directions("room", "room") == {
+        "directions": ["You are already at your destination."],
+        "coordinates": [{"x": 12, "y": -3, "floor": 5}],
+    }
+
+
+@pytest.mark.parametrize(
+    ("current_type", "next_type", "expected"),
+    [
+        ("staircase", "waypoint", "Take the stairs from floor 1 to floor 2."),
+        ("waypoint", "staircase", "Take the stairs from floor 1 to floor 2."),
+        ("elevator", "waypoint", "Move from floor 1 to floor 2."),
+        ("waypoint", "elevator", "Move from floor 1 to floor 2."),
+        ("waypoint", "waypoint", "Move from floor 1 to floor 2."),
+    ],
+)
+def test_get_directions_describes_floor_changes(current_type, next_type, expected):
+    manager.G = make_graph(
+        ("start", node(floor=1, node_type=current_type)),
+        ("end", node(floor=2, node_type=next_type)),
+        edges=[("start", "end", {"weight": 1, "instruction": "Ignore me."})],
+    )
+
+    result = manager.get_directions("start", "end")
+
+    assert result["directions"] == [expected]
+    assert [coordinate["floor"] for coordinate in result["coordinates"]] == [1, 2]
+
+
+def test_get_directions_preserves_generated_elevator_instruction_between_connectors():
+    manager.G = make_graph(
+        ("NPB_5_E1", node(floor=5, node_type="elevator")),
+        ("NPB_4_E1", node(floor=4, node_type="elevator")),
+        edges=[
+            (
+                "NPB_5_E1",
+                "NPB_4_E1",
+                {
+                    "weight": 20,
+                    "instruction": "Take elevator E1 to floor 4.",
+                },
+            )
+        ],
+    )
+
+    result = manager.get_directions("NPB_5_E1", "NPB_4_E1")
+
+    assert result["directions"] == ["Take elevator E1 to floor 4."]
+
+
+def test_get_directions_returns_message_when_no_path_exists():
+    manager.G = make_graph(("start", node()), ("end", node()))
+
+    assert manager.get_directions("start", "end") == "No path found from start to end."
+
+
+@pytest.mark.parametrize(
+    ("start", "end"),
+    [("missing", "end"), ("start", "missing")],
+)
+def test_get_directions_returns_message_for_missing_nodes(start, end):
+    manager.G = make_graph(("start", node()), ("end", node()))
+
+    assert manager.get_directions(start, end) == (
+        f"No path found from {start} to {end}."
+    )
+
+
+def test_get_directions_uses_weighted_route_instructions():
+    manager.G = make_graph(
+        ("start", node(x=0, y=0)),
+        ("direct", node(x=10, y=0)),
+        ("detour", node(x=2, y=0)),
+        ("end", node(x=4, y=0)),
+        edges=[
+            ("start", "direct", {"weight": 10, "instruction": "Take direct."}),
+            ("direct", "end", {"weight": 10, "instruction": "Finish direct."}),
+            ("start", "detour", {"weight": 2, "instruction": "Take detour."}),
+            ("detour", "end", {"weight": 3, "instruction": "Finish detour."}),
+        ],
+    )
+
+    result = manager.get_directions("start", "end")
+
+    assert result["directions"] == ["Take detour.", "Finish detour."]
+    assert [coordinate["x"] for coordinate in result["coordinates"]] == [0, 2, 4]
+
+
+def test_get_directions_reuses_cached_graph(monkeypatch):
+    manager.G = make_graph(
+        ("start", node()),
+        ("end", node()),
+        edges=[("start", "end", {"weight": 1, "instruction": "Arrive."})],
+    )
+    reload_calls = []
+    monkeypatch.setattr(manager, "reload_graph", lambda: reload_calls.append(True))
+
+    assert manager.get_directions("start", "end")["directions"] == ["Arrive."]
+    assert reload_calls == []
+
+
+def test_get_directions_lazily_loads_graph(monkeypatch):
+    graph = make_graph(
+        ("start", node()),
+        ("end", node()),
+        edges=[("start", "end", {"weight": 1, "instruction": "Arrive."})],
+    )
+
+    def load_graph():
+        manager.G = graph
+
+    monkeypatch.setattr(manager, "reload_graph", load_graph)
+
+    assert manager.get_directions("start", "end")["directions"] == ["Arrive."]
+
+
+def test_main_draws_positioned_subgraph_and_saves_preview(monkeypatch):
+    nodes = [
+        {"id": "positioned", "coords": [10, 20]},
+        {"id": "unpositioned", "coords": [None, 30]},
+    ]
+    graph = make_graph(
+        ("positioned", node(x=10, y=20)),
+        ("unpositioned", node(x=None, y=30)),
+        edges=[("positioned", "unpositioned", {"weight": 1, "instruction": "Go."})],
+    )
+    drawn = []
+    saved = []
+    direction_calls = []
+    monkeypatch.setattr(manager, "read_json_files", lambda: (nodes, []))
+    monkeypatch.setattr(manager, "build_graph", lambda: graph)
+    monkeypatch.setattr(
+        manager.nx,
+        "draw",
+        lambda graph, pos, **kwargs: drawn.append((graph, pos, kwargs)),
+    )
+    monkeypatch.setattr(manager.plt, "savefig", lambda path: saved.append(path))
+    monkeypatch.setattr(
+        manager,
+        "get_directions",
+        lambda start, end: direction_calls.append((start, end)),
+    )
+
+    manager.main()
+
+    assert manager.G is graph
+    assert len(drawn) == 1
+    assert set(drawn[0][0].nodes) == {"positioned"}
+    assert drawn[0][1] == {"positioned": (10, 20)}
+    assert saved == ["map_preview.png"]
+    assert direction_calls == [("NPB_5_102", "NPB_5_E1")]
+
+
+def test_logic_exports_public_graph_manager_api():
+    assert logic.__all__ == ["get_directions", "get_floor_bounds", "get_options"]
+    assert logic.get_directions is manager.get_directions
+    assert logic.get_floor_bounds is manager.get_floor_bounds
+    assert logic.get_options is manager.get_options
diff --git a/tests/test_routes.py b/tests/test_routes.py
new file mode 100644
index 0000000..c5ad2d6
--- /dev/null
+++ b/tests/test_routes.py
@@ -0,0 +1,247 @@
+import json
+import re
+from unittest.mock import Mock
+
+import pytest
+
+from app import logic, routes
+from app.logic import graph_manager
+
+OPTIONS = (
+    [{"id": "NPB_5_E1", "name": "5.E1 elevator"}],
+    [{"id": "NPB_5_154", "name": "5.154"}],
+)
+
+
+@pytest.fixture(autouse=True)
+def stub_options(monkeypatch):
+    monkeypatch.setattr(routes, "get_options", lambda: OPTIONS)
+
+
+def embedded_json(body, variable):
+    """Read a JSON value exposed by the page's JavaScript contract."""
+    match = re.search(
+        rf"(?:window\.)?{re.escape(variable)}\s*=\s*(?P<value>.*?);",
+        body,
+        flags=re.DOTALL,
+    )
+    assert match, f"{variable} was not embedded in the response"
+    return json.loads(match.group("value"))
+
+
+def test_index_renders_form_options_and_map_placeholder(client):
+    response = client.get("/")
+
+    assert response.status_code == 200
+    body = response.get_data(as_text=True)
+    assert "<h1>Choose Your Options</h1>" in body
+    assert '<form method="post" action="/directions">' in body
+    assert '<button type="submit">Get Directions</button>' in body
+    assert '<select id="entrance" name="entrance">' in body
+    assert 'value="NPB_5_E1">5.E1 elevator' in body
+    assert '<select id="classroom" name="classroom">' in body
+    assert 'value="NPB_5_154">5.154' in body
+    assert "Map will appear here after you select directions" in body
+    assert "/static/css/styles.css" in body
+    assert "window.routeCoordinates" not in body
+
+
+@pytest.mark.parametrize(
+    "form_data",
+    [
+        {},
+        {"entrance": "NPB_5_E1"},
+        {"classroom": "NPB_5_154"},
+        {"entrance": "", "classroom": "NPB_5_154"},
+        {"entrance": "NPB_5_E1", "classroom": ""},
+    ],
+)
+def test_directions_rejects_missing_form_values(client, monkeypatch, form_data):
+    get_directions = Mock()
+    monkeypatch.setattr(routes, "get_directions", get_directions)
+
+    response = client.post("/directions", data=form_data)
+
+    assert response.status_code == 200
+    assert "Missing entrance or classroom parameter" in response.get_data(as_text=True)
+    get_directions.assert_not_called()
+
+
+def test_directions_only_accepts_post(client):
+    response = client.get("/directions")
+
+    assert response.status_code == 405
+
+
+def test_live_index_and_multi_floor_post_use_canonical_data(client, monkeypatch):
+    monkeypatch.setattr(routes, "get_options", logic.get_options)
+    graph_manager.G = None
+
+    index_response = client.get("/")
+    assert index_response.status_code == 200
+    index_body = index_response.get_data(as_text=True)
+    assert 'value="NPB_5_E1">5.E1' in index_body
+    assert 'value="NPB_4_440">4.440' in index_body
+
+    response = client.post(
+        "/directions",
+        data={"entrance": "NPB_5_E1", "classroom": "NPB_4_440"},
+    )
+
+    assert response.status_code == 200
+    body = response.get_data(as_text=True)
+    assert "Take elevator E1 to floor 4." in body
+    assert "Map preview is unavailable for routes spanning multiple floors." in body
+    assert "window.routeCoordinates" not in body
+
+
+def test_directions_embeds_route_and_uses_entrance_building_and_first_floor(
+    client, monkeypatch
+):
+    route = {
+        "directions": ["Leave the elevator.", "Turn left at the hallway."],
+        "coordinates": [
+            {"x": 1, "y": 2, "floor": 4},
+            {"x": 3.5, "y": -6, "floor": 4},
+        ],
+    }
+    get_directions = Mock(return_value=route)
+    get_floor_bounds = Mock(return_value={"width": 300, "height": 60})
+    monkeypatch.setattr(routes, "get_directions", get_directions)
+    monkeypatch.setattr(routes, "get_floor_bounds", get_floor_bounds)
+
+    response = client.post(
+        "/directions",
+        data={"entrance": "NPB_5_E1", "classroom": "NPB_5_154"},
+    )
+
+    assert response.status_code == 200
+    body = response.get_data(as_text=True)
+    assert embedded_json(body, "directionSteps") == route["directions"]
+    assert embedded_json(body, "routeCoordinates") == route["coordinates"]
+    assert embedded_json(body, "floorBounds") == {"width": 300, "height": 60}
+    assert 'id="directions-panel"' in body
+    assert "/static/js/directions.js" in body
+    assert "/static/js/map.js" in body
+    get_directions.assert_called_once_with("NPB_5_E1", "NPB_5_154")
+    get_floor_bounds.assert_called_once_with("NPB", 4)
+
+
+def test_directions_displays_no_route_error(client, monkeypatch):
+    get_directions = Mock(return_value="No path found from start to end.")
+    get_floor_bounds = Mock()
+    monkeypatch.setattr(routes, "get_directions", get_directions)
+    monkeypatch.setattr(routes, "get_floor_bounds", get_floor_bounds)
+
+    response = client.post(
+        "/directions",
+        data={"entrance": "NPB_5_E1", "classroom": "NPB_5_154"},
+    )
+
+    assert response.status_code == 200
+    body = response.get_data(as_text=True)
+    assert (
+        "No route could be found between the selected entrance and destination." in body
+    )
+    assert "window.routeCoordinates" not in body
+    assert "window.floorBounds" not in body
+    get_directions.assert_called_once_with("NPB_5_E1", "NPB_5_154")
+    get_floor_bounds.assert_not_called()
+
+
+def test_directions_displays_runtime_error(client, monkeypatch):
+    get_directions = Mock(side_effect=RuntimeError("data is unavailable"))
+    get_floor_bounds = Mock()
+    monkeypatch.setattr(routes, "get_directions", get_directions)
+    monkeypatch.setattr(routes, "get_floor_bounds", get_floor_bounds)
+
+    response = client.post(
+        "/directions",
+        data={"entrance": "NPB_5_E1", "classroom": "NPB_5_154"},
+    )
+
+    assert response.status_code == 200
+    assert "data is unavailable" in response.get_data(as_text=True)
+    get_floor_bounds.assert_not_called()
+
+
+def test_directions_displays_floor_bounds_runtime_error(client, monkeypatch):
+    route = {
+        "directions": ["Leave the elevator."],
+        "coordinates": [{"x": 1, "y": 2, "floor": 4}],
+    }
+    monkeypatch.setattr(routes, "get_directions", Mock(return_value=route))
+    monkeypatch.setattr(
+        routes,
+        "get_floor_bounds",
+        Mock(side_effect=RuntimeError("floor data is unavailable")),
+    )
+
+    response = client.post(
+        "/directions",
+        data={"entrance": "NPB_5_E1", "classroom": "NPB_5_154"},
+    )
+
+    assert response.status_code == 200
+    assert "floor data is unavailable" in response.get_data(as_text=True)
+
+
+def test_directions_does_not_request_floor_bounds_for_empty_coordinates(
+    client, monkeypatch
+):
+    route = {
+        "directions": ["The route has no mappable coordinates."],
+        "coordinates": [],
+    }
+    get_floor_bounds = Mock()
+    monkeypatch.setattr(routes, "get_directions", Mock(return_value=route))
+    monkeypatch.setattr(routes, "get_floor_bounds", get_floor_bounds)
+
+    response = client.post(
+        "/directions",
+        data={"entrance": "NPB_5_E1", "classroom": "NPB_5_154"},
+    )
+
+    assert response.status_code == 200
+    body = response.get_data(as_text=True)
+    assert embedded_json(body, "directionSteps") == route["directions"]
+    assert "window.routeCoordinates" not in body
+    assert "window.floorBounds" not in body
+    assert "Map will appear here after you select directions" in body
+    get_floor_bounds.assert_not_called()
+
+
+def test_api_test_returns_json_from_pathfinder(client, monkeypatch):
+    expected = {"directions": ["Test route"], "coordinates": []}
+    get_directions = Mock(return_value=expected)
+    monkeypatch.setattr(routes, "get_directions", get_directions)
+
+    response = client.get("/api/test")
+
+    assert response.status_code == 200
+    assert response.is_json
+    assert response.mimetype == "application/json"
+    assert response.get_json() == expected
+    get_directions.assert_called_once_with("NPB_5_E1", "NPB_5_154")
+
+
+def test_unknown_url_returns_not_found(client):
+    response = client.get("/does-not-exist")
+
+    assert response.status_code == 404
+
+
+@pytest.mark.parametrize(
+    ("path", "mimetype"),
+    [
+        ("/static/css/styles.css", "text/css"),
+        ("/static/js/directions.js", "text/javascript"),
+        ("/static/js/map.js", "text/javascript"),
+    ],
+)
+def test_static_assets_are_served(client, path, mimetype):
+    response = client.get(path)
+
+    assert response.status_code == 200
+    assert response.mimetype == mimetype
+    assert response.data
diff --git a/tests/test_smoke.py b/tests/test_smoke.py
index f6300c0..50a68ad 100644
--- a/tests/test_smoke.py
+++ b/tests/test_smoke.py
@@ -1,23 +1,59 @@
-"""Smoke tests: keep CI honest until a real suite exists."""
+import runpy
+from pathlib import Path
+from unittest.mock import Mock
 
+import pytest
 
-def test_app_factory_boots():
-    """App factory builds without import-time graph loading."""
-    from app import create_app
-
-    app = create_app()
-
-    assert app is not None
 
-
-def test_api_test_route_serves_directions():
-    """GET /api/test loads the graph from live data and routes a query."""
+def test_app_factory_registers_blueprint_without_loading_graph(monkeypatch):
+    """Creating the Flask app must not read or build the graph."""
     from app import create_app
+    from app.logic import graph_manager
+
+    read_json_files = Mock(side_effect=AssertionError("graph data loaded too early"))
+    build_graph = Mock(side_effect=AssertionError("graph built too early"))
+    monkeypatch.setattr(graph_manager, "read_json_files", read_json_files)
+    monkeypatch.setattr(graph_manager, "build_graph", build_graph)
 
-    client = create_app().test_client()
-    resp = client.get("/api/test")
+    app = create_app()
 
-    assert resp.status_code == 200
-    data = resp.get_json()
-    assert isinstance(data, dict)
-    assert "directions" in data
+    assert app.blueprints["main"].name == "main"
+    rules = {rule.rule: rule for rule in app.url_map.iter_rules()}
+    assert {"GET", "HEAD", "OPTIONS"} <= rules["/"].methods
+    assert {"POST", "OPTIONS"} <= rules["/directions"].methods
+    assert {"GET", "HEAD", "OPTIONS"} <= rules["/api/test"].methods
+    assert rules["/"].endpoint == "main.index"
+    assert rules["/directions"].endpoint == "main.directions"
+    assert rules["/api/test"].endpoint == "main.test"
+    read_json_files.assert_not_called()
+    build_graph.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    ("debug_value", "expected_debug"),
+    [
+        (None, False),
+        ("0", False),
+        ("false", False),
+        ("1", True),
+        ("true", True),
+        ("True", True),
+    ],
+)
+def test_run_entry_point_passes_debug_environment_to_flask(
+    monkeypatch, debug_value, expected_debug
+):
+    if debug_value is None:
+        monkeypatch.delenv("FLASK_DEBUG", raising=False)
+    else:
+        monkeypatch.setenv("FLASK_DEBUG", debug_value)
+
+    run_server = Mock()
+    monkeypatch.setattr("flask.Flask.run", run_server)
+
+    namespace = runpy.run_path(
+        str(Path(__file__).resolve().parents[1] / "run.py"), run_name="__main__"
+    )
+
+    assert namespace["app"].name == "app"
+    run_server.assert_called_once_with(debug=expected_debug)
diff --git a/tests/test_validate_data.py b/tests/test_validate_data.py
new file mode 100644
index 0000000..fb8b52b
--- /dev/null
+++ b/tests/test_validate_data.py
@@ -0,0 +1,273 @@
+import json
+
+import pytest
+
+from tools import validate_data
+
+
+def write_data(monkeypatch, tmp_path, nodes, edges):
+    data_dir = tmp_path / "data"
+    data_dir.mkdir()
+    (data_dir / "nodes.json").write_text(json.dumps(nodes), encoding="utf-8")
+    (data_dir / "edges.json").write_text(json.dumps(edges), encoding="utf-8")
+    monkeypatch.setattr(validate_data, "DATA_DIR", data_dir)
+    return data_dir
+
+
+def valid_nodes():
+    return [
+        {
+            "id": "BLDG_1_a",
+            "name": "A",
+            "type": "room",
+            "building": "BLDG",
+            "floor": 1,
+            "coords": [1, 2],
+        },
+        {
+            "id": "BLDG_1_b",
+            "name": "B",
+            "type": "waypoint",
+            "building": "BLDG",
+            "floor": 1,
+            "coords": [3.5, 4],
+        },
+    ]
+
+
+def valid_edges():
+    return [
+        {
+            "source": "BLDG_1_a",
+            "target": "BLDG_1_b",
+            "weight": 2,
+            "instruction": "Go forward.",
+        },
+        {
+            "source": "BLDG_1_b",
+            "target": "BLDG_1_a",
+            "weight": 2,
+            "instruction": "Turn around.",
+        },
+    ]
+
+
+def test_main_accepts_valid_data_and_numeric_float_weights(
+    monkeypatch, tmp_path, capsys
+):
+    edges = valid_edges()
+    edges[0]["weight"] = 2.5
+    write_data(monkeypatch, tmp_path, valid_nodes(), edges)
+
+    validate_data.main()
+
+    assert "Data OK — 2 nodes, 2 edges (2 connections)" in capsys.readouterr().out
+
+
+def test_main_reports_non_blocking_prefix_warning(monkeypatch, tmp_path, capsys):
+    nodes = valid_nodes()
+    nodes[0]["id"] = "wrong-prefix"
+    edges = [
+        {
+            "source": "wrong-prefix",
+            "target": "BLDG_1_b",
+            "weight": 2,
+            "instruction": "Go forward.",
+        },
+        {
+            "source": "BLDG_1_b",
+            "target": "wrong-prefix",
+            "weight": 2,
+            "instruction": "Turn around.",
+        },
+    ]
+    write_data(monkeypatch, tmp_path, nodes, edges)
+
+    validate_data.main()
+
+    output = capsys.readouterr().out
+    assert "id doesn't start with building prefix 'BLDG_'" in output
+    assert "Data OK — 2 nodes, 2 edges (2 connections)" in output
+    assert "1 warning(s) above" in output
+
+
+@pytest.mark.parametrize(
+    ("field", "value", "message"),
+    [
+        ("name", "", "name must be non-empty text"),
+        ("type", 1, "type must be non-empty text"),
+        ("building", True, "building must be non-empty text"),
+        ("floor", True, "floor must be an integer"),
+    ],
+)
+def test_main_rejects_invalid_node_field_types(
+    monkeypatch, tmp_path, field, value, message, capsys
+):
+    nodes = valid_nodes()
+    nodes[0][field] = value
+    write_data(monkeypatch, tmp_path, nodes, valid_edges())
+
+    with pytest.raises(SystemExit) as exc_info:
+        validate_data.main()
+
+    assert exc_info.value.code == 1
+    assert message in capsys.readouterr().out
+
+
+def test_main_reports_reverse_edge_warning_without_exiting(
+    monkeypatch, tmp_path, capsys
+):
+    write_data(monkeypatch, tmp_path, valid_nodes(), valid_edges()[:1])
+
+    validate_data.main()
+
+    output = capsys.readouterr().out
+    assert "no reverse edge exists" in output
+    assert "Data OK — 2 nodes, 1 edges (1 connections)" in output
+    assert "1 warning(s) above" in output
+
+
+def test_main_exits_and_reports_schema_and_reference_errors(
+    monkeypatch, tmp_path, capsys
+):
+    nodes = valid_nodes() + [
+        {
+            "id": "BLDG_1_a",
+            "name": "Duplicate",
+            "type": "room",
+            "building": "BLDG",
+            "floor": 1,
+            "coords": [0, 0],
+        },
+        {"id": "incomplete"},
+    ]
+    edges = [
+        {
+            "source": "BLDG_1_a",
+            "target": "missing",
+            "weight": "heavy",
+            "instruction": "  ",
+        },
+        {"source": "BLDG_1_a"},
+    ]
+    write_data(monkeypatch, tmp_path, nodes, edges)
+
+    with pytest.raises(SystemExit) as exc_info:
+        validate_data.main()
+
+    assert exc_info.value.code == 1
+    output = capsys.readouterr().out
+    assert "duplicate node id 'BLDG_1_a'" in output
+    assert "missing field(s)" in output
+    assert "'missing' is not a known node id" in output
+    assert "weight must be a number" in output
+    assert "instruction must be non-empty text" in output
+    assert "problem(s) found in data/" in output
+
+
+@pytest.mark.parametrize(
+    "coords",
+    [[1], [1, 2, 3], "1,2", [1, "2"], [True, 2], None],
+)
+def test_main_rejects_invalid_coordinate_shapes(monkeypatch, tmp_path, coords, capsys):
+    nodes = valid_nodes()
+    nodes[0]["coords"] = coords
+    write_data(monkeypatch, tmp_path, nodes, valid_edges())
+
+    with pytest.raises(SystemExit) as exc_info:
+        validate_data.main()
+
+    assert exc_info.value.code == 1
+    output = capsys.readouterr().out
+    assert "coords must be [x, y] numbers" in output
+    assert "node 'BLDG_1_a'" in output
+
+
+@pytest.mark.parametrize("instruction", ["", "  \n", None, 123])
+def test_main_rejects_empty_or_non_text_instructions(
+    monkeypatch, tmp_path, instruction, capsys
+):
+    edges = valid_edges()
+    edges[0]["instruction"] = instruction
+    write_data(monkeypatch, tmp_path, valid_nodes(), edges)
+
+    with pytest.raises(SystemExit) as exc_info:
+        validate_data.main()
+
+    assert exc_info.value.code == 1
+    assert "instruction must be non-empty text" in capsys.readouterr().out
+
+
+@pytest.mark.parametrize("weight", ["2", None, [], {"cost": 2}, True, False])
+def test_main_rejects_non_numeric_weights(monkeypatch, tmp_path, weight, capsys):
+    edges = valid_edges()
+    edges[0]["weight"] = weight
+    write_data(monkeypatch, tmp_path, valid_nodes(), edges)
+
+    with pytest.raises(SystemExit) as exc_info:
+        validate_data.main()
+
+    assert exc_info.value.code == 1
+    output = capsys.readouterr().out
+    assert "weight must be a number" in output
+    assert repr(weight) in output
+
+
+@pytest.mark.parametrize(
+    ("nodes", "edges", "message"),
+    [
+        (
+            {"not": "a list"},
+            valid_edges(),
+            "nodes.json: top-level value must be a list",
+        ),
+        (
+            valid_nodes(),
+            {"not": "a list"},
+            "edges.json: top-level value must be a list",
+        ),
+        (["not an object"], valid_edges(), "nodes.json[0]: entry must be an object"),
+        (valid_nodes(), ["not an object"], "edges.json[0]: entry must be an object"),
+    ],
+)
+def test_main_rejects_wrong_json_shapes_and_entries(
+    monkeypatch, tmp_path, nodes, edges, message, capsys
+):
+    write_data(monkeypatch, tmp_path, nodes, edges)
+
+    with pytest.raises(SystemExit) as exc_info:
+        validate_data.main()
+
+    assert exc_info.value.code == 1
+    assert message in capsys.readouterr().out
+
+
+@pytest.mark.parametrize("missing_name", ["nodes.json", "edges.json"])
+def test_load_exits_for_missing_data_file(monkeypatch, tmp_path, missing_name, capsys):
+    data_dir = tmp_path / "data"
+    data_dir.mkdir()
+    monkeypatch.setattr(validate_data, "DATA_DIR", data_dir)
+
+    with pytest.raises(SystemExit) as exc_info:
+        validate_data.load(missing_name)
+
+    assert exc_info.value.code == 1
+    output = capsys.readouterr().out
+    assert "Missing file" in output
+    assert missing_name in output
+
+
+@pytest.mark.parametrize("filename", ["nodes.json", "edges.json"])
+def test_load_exits_for_malformed_json(monkeypatch, tmp_path, filename, capsys):
+    data_dir = tmp_path / "data"
+    data_dir.mkdir()
+    (data_dir / filename).write_text("{", encoding="utf-8")
+    monkeypatch.setattr(validate_data, "DATA_DIR", data_dir)
+
+    with pytest.raises(SystemExit) as exc_info:
+        validate_data.load(filename)
+
+    assert exc_info.value.code == 1
+    output = capsys.readouterr().out
+    assert f"{filename} is not valid JSON" in output
+    assert "line 1" in output
diff --git a/tools/generate_vertical_edges.py b/tools/generate_vertical_edges.py
index fbef6c4..93e670e 100644
--- a/tools/generate_vertical_edges.py
+++ b/tools/generate_vertical_edges.py
@@ -38,31 +38,40 @@ def save_json(path, data):
 
 def discover_connectors(nodes):
     """
-    Scan nodes for known connector suffixes and return a dict of:
-        suffix -> {"type": "elevator"|"staircase", "floors": [...], "name": str}
+    Scan nodes for known connector suffixes and return a dict keyed by
+    ``(building, suffix)``. Keeping the building in the key prevents two
+    buildings with an ``E1`` or ``S1`` connector from being merged.
     """
     found = {}
     for node in nodes:
         node_id = node["id"]
-        parts = node_id.split(
-            "_", 2
-        )  # e.g. ["NPB", "5", "E1"] or ["NPB", "4", "stairs_main"]
+        parts = node_id.split("_", 2)
         if len(parts) < 3:
             continue
-        suffix = parts[2]
+
+        embedded_building, _, suffix = parts
         if suffix not in CONNECTORS:
             continue
-        floor = node["floor"]
-        if suffix not in found:
-            found[suffix] = {
+
+        building = node.get("building", embedded_building)
+        if building != embedded_building:
+            raise ValueError(
+                f"Node '{node_id}' has building '{building}', but its ID uses "
+                f"'{embedded_building}'"
+            )
+
+        key = (building, suffix)
+        if key not in found:
+            found[key] = {
                 "type": "elevator" if suffix in ELEVATORS else "staircase",
-                "floors": [],
+                "floors": set(),
                 "name": node["name"],
-                "building": node.get("building", "NPB"),
+                "building": building,
             }
-        found[suffix]["floors"].append(floor)
-    for suffix in found:
-        found[suffix]["floors"].sort()
+        found[key]["floors"].add(node["floor"])
+
+    for info in found.values():
+        info["floors"] = sorted(info["floors"])
     return found
 
 
@@ -77,9 +86,15 @@ def make_edge(source_id, target_id, weight, instruction):
 
 def generate_edges(connectors):
     new_edges = []
-    for suffix, info in connectors.items():
-        floors = info["floors"]
-        building = info["building"]
+    for key, info in connectors.items():
+        if isinstance(key, tuple):
+            building, suffix = key
+        else:
+            # Accept the old suffix-only shape for callers that construct
+            # connector metadata directly.
+            suffix = key
+            building = info["building"]
+        floors = sorted(set(info["floors"]))
         node_type = info["type"]
 
         if node_type == "elevator":
@@ -87,7 +102,7 @@ def generate_edges(connectors):
         else:
             pairs = [
                 (floor_a, floor_b)
-                for floor_a, floor_b in itertools.pairwise(floors, floors[1:])
+                for floor_a, floor_b in itertools.pairwise(floors)
                 if floor_b == floor_a + 1
             ]
 
diff --git a/tools/validate_data.py b/tools/validate_data.py
index c6b4b27..c445fc6 100644
--- a/tools/validate_data.py
+++ b/tools/validate_data.py
@@ -6,15 +6,17 @@
 
   Errors (must fix):
     - malformed JSON (missing comma, bad quote, trailing comma)
+    - nodes.json or edges.json has the wrong top-level shape
+    - node or edge entries that aren't objects
     - node missing required fields (id, name, type, building, floor, coords)
     - edge missing required fields (source, target, weight, instruction)
     - duplicate node ids
     - edge pointing at a node that doesn't exist
     - non-numeric edge weight
     - coords that aren't a [x, y] pair
-    - an edge that has no reverse edge (connections must be bidirectional)
 
   Warnings (probably wrong, doesn't block):
+    - an edge has no reverse edge (connections should be bidirectional)
     - node id doesn't start with the building prefix (e.g. NPB_5_102)
 
 Usage:
@@ -32,6 +34,10 @@
 REQUIRED_EDGE_FIELDS = {"source", "target", "weight", "instruction"}
 
 
+def is_number(value):
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
 def load(name):
     path = DATA_DIR / name
     try:
@@ -53,15 +59,35 @@ def main():
     errors = []
     warnings = []
 
+    if not isinstance(nodes, list):
+        errors.append(
+            f"nodes.json: top-level value must be a list, got {type(nodes).__name__}"
+        )
+        nodes = []
+    if not isinstance(edges, list):
+        errors.append(
+            f"edges.json: top-level value must be a list, got {type(edges).__name__}"
+        )
+        edges = []
+
     # ---- nodes ----
     node_ids = set()
     for i, node in enumerate(nodes):
+        if not isinstance(node, dict):
+            errors.append(
+                f"nodes.json[{i}]: entry must be an object, got {type(node).__name__}"
+            )
+            continue
+
         missing = REQUIRED_NODE_FIELDS - set(node)
         if missing:
             errors.append(f"nodes.json[{i}]: missing field(s) {sorted(missing)}")
             continue
 
         node_id = node["id"]
+        if not isinstance(node_id, str) or not node_id.strip():
+            errors.append(f"nodes.json[{i}]: id must be non-empty text")
+            continue
         if node_id in node_ids:
             errors.append(f"nodes.json: duplicate node id '{node_id}'")
         node_ids.add(node_id)
@@ -70,38 +96,56 @@ def main():
         if (
             not isinstance(coords, list)
             or len(coords) != 2
-            or not all(isinstance(v, (int, float)) for v in coords)
+            or not all(is_number(value) for value in coords)
         ):
             errors.append(
                 f"node '{node_id}': coords must be [x, y] numbers, got {coords!r}"
             )
 
-        if not node_id.startswith(node["building"] + "_"):
+        for field in ("name", "type"):
+            if not isinstance(node[field], str) or not node[field].strip():
+                errors.append(f"node '{node_id}': {field} must be non-empty text")
+
+        if not isinstance(node["floor"], int) or isinstance(node["floor"], bool):
+            errors.append(f"node '{node_id}': floor must be an integer")
+
+        building = node["building"]
+        if not isinstance(building, str) or not building.strip():
+            errors.append(f"node '{node_id}': building must be non-empty text")
+        elif not node_id.startswith(building + "_"):
             warnings.append(
-                f"node '{node_id}': id doesn't start with building "
-                f"prefix '{node['building']}_'"
+                f"node '{node_id}': id doesn't start with building prefix '{building}_'"
             )
 
     # ---- edges ----
     edge_pairs = set()
     for i, edge in enumerate(edges):
+        if not isinstance(edge, dict):
+            errors.append(
+                f"edges.json[{i}]: entry must be an object, got {type(edge).__name__}"
+            )
+            continue
+
         missing = REQUIRED_EDGE_FIELDS - set(edge)
         if missing:
             errors.append(f"edges.json[{i}]: missing field(s) {sorted(missing)}")
             continue
 
-        label = f"{edge['source']} → {edge['target']}"
-        for field in ("source", "target"):
-            if edge[field] not in node_ids:
-                errors.append(f"edge {label}: '{edge[field]}' is not a known node id")
-        if not isinstance(edge["weight"], (int, float)):
+        source = edge["source"]
+        target = edge["target"]
+        label = f"{source} → {target}"
+        for field, node_ref in (("source", source), ("target", target)):
+            if not isinstance(node_ref, str) or node_ref not in node_ids:
+                errors.append(f"edge {label}: '{node_ref}' is not a known node id")
+        if not is_number(edge["weight"]):
             errors.append(
                 f"edge {label}: weight must be a number, got {edge['weight']!r}"
             )
         if not isinstance(edge["instruction"], str) or not edge["instruction"].strip():
             errors.append(f"edge {label}: instruction must be non-empty text")
 
-        edge_pairs.add((edge["source"], edge["target"]))
+        if isinstance(source, str) and isinstance(target, str):
+            edge_pairs.add((source, target))
 
     for source, target in sorted(edge_pairs):
         if (target, source) not in edge_pairs: