diff --git a/app/billing/backend/supplier_invoices.py b/app/billing/backend/supplier_invoices.py
index 6fe80f3..0336632 100644
--- a/app/billing/backend/supplier_invoices.py
+++ b/app/billing/backend/supplier_invoices.py
@@ -8,6 +8,7 @@ from pydantic import BaseModel
 from typing import List, Dict, Optional
 from datetime import datetime, date, timedelta
 from decimal import Decimal
+import ipaddress
 from pathlib import Path
 from app.core.database import execute_query, execute_insert, execute_update, execute_query_single, table_has_column
 from app.core.config import settings
@@ -227,6 +228,112 @@ def _resolve_procurement_customer_id() -> int:
     raise ValueError("No active customer available for procurement case creation")
 
 
+def _resolve_group_id_by_name_tokens(tokens: List[str]) -> Optional[int]:
+    lowered = [str(token or "").strip().lower() for token in tokens if str(token or "").strip()]
+    if not lowered:
+        return None
+
+    clauses = " OR ".join(["LOWER(name) LIKE %s" for _ in lowered])
+    params = tuple(f"%{token}%" for token in lowered)
+    row = execute_query_single(
+        f"""
+        SELECT id
+        FROM groups
+        WHERE {clauses}
+        ORDER BY id
+        LIMIT 1
+        """,
+        params,
+    )
+    return int(row["id"]) if row and row.get("id") else None
+
+
+def _ensure_internet_change_case(
+    connection_id: int,
+    invoice_number: str,
+    reference: str,
+    connection_name: str,
+    owner_customer_id: Optional[int],
+    changes: Dict[str, Dict[str, object]],
+) -> Optional[int]:
+    if not changes:
+        return None
+
+    title = f"Internet ændring {reference or connection_name} - faktura {invoice_number}"
+    existing = execute_query_single(
+        """
+        SELECT id
+        FROM sag_sager
+        WHERE deleted_at IS NULL
+          AND titel = %s
+        ORDER BY id DESC
+        LIMIT 1
+        """,
+        (title,),
+    )
+    if existing:
+        return int(existing["id"])
+
+    assigned_group_id = _resolve_group_id_by_name_tokens(["økonomi", "okonomi", "economic"])
+    try:
+        case_customer_id = owner_customer_id or _resolve_procurement_customer_id()
+    except Exception as exc:
+        logger.warning(
+            "Skipping automatic internet change case for connection %s on invoice %s: could not resolve case customer (%s)",
+            connection_id,
+            invoice_number,
+            exc,
+        )
+        return None
+    change_lines = "\n".join(
+        f"- {field}: {change.get('from')} -> {change.get('to')}"
+        for field, change in changes.items()
+    )
+    description = (
+        "Automatisk oprettet ved import af internetfaktura.\n"
+        f"Forbindelse: {connection_name}\n"
+        f"Reference: {reference or '-'}\n"
+        f"Faktura: {invoice_number}\n"
+        "Registrerede ændringer:\n"
+        f"{change_lines}"
+    )
+
+    try:
+        try:
+            row = execute_query_single(
+                """
+                INSERT INTO sag_sager (
+                    titel, beskrivelse, type, status, customer_id, assigned_group_id, created_by_user_id
+                )
+                VALUES (%s, %s, %s, %s, %s, %s, %s)
+                RETURNING id
+                """,
+                (title, description, _PURCHASE_CASE_TYPE, "åben", case_customer_id, assigned_group_id, 1),
+            )
+        except Exception as insert_error:
+            if 'column "type"' not in str(insert_error):
+                raise
+            row = execute_query_single(
+                """
+                INSERT INTO sag_sager (
+                    titel, beskrivelse, status, customer_id, assigned_group_id, created_by_user_id
+                )
+                VALUES (%s, %s, %s, %s, %s, %s)
+                RETURNING id
+                """,
+                (title, description, "åben", case_customer_id, assigned_group_id, 1),
+            )
+    except Exception as exc:
+        logger.warning(
+            "Skipping automatic internet change case for connection %s on invoice %s: %s",
+            connection_id,
+            invoice_number,
+            exc,
+        )
+        return None
+    return int(row["id"]) if row and row.get("id") else None
+
+
 def _ensure_case_for_supplier_invoice(
     invoice_id: int,
     invoice_number: str,
@@ -319,6 +426,79 @@ def _ensure_case_for_supplier_invoice(
     return sag_id
 
 
+def _append_amount_validation_case_note(
+    sag_id: Optional[int],
+    invoice_id: int,
+    invoice_number: str,
+    validation_details: Optional[Dict],
+    validation_warning: Optional[str],
+    vat_warning: Optional[str],
+    file_id: Optional[int] = None,
+) -> None:
+    if not sag_id:
+        return
+    if not validation_warning and not vat_warning:
+        return
+
+    details = validation_details or {}
+    line_sum = details.get("line_sum")
+    subtotal = details.get("subtotal")
+    difference = details.get("difference")
+    vat_amount = details.get("vat_amount")
+    vat_expected = details.get("vat_expected")
+    vat_difference = details.get("vat_difference")
+
+    note_lines = [
+        "Automatisk valideringsadvarsel på leverandørfaktura",
+        f"Faktura: {invoice_number}",
+        f"Invoice ID: {invoice_id}",
+        f"Fil ID: {file_id or '-'}",
+    ]
+    if validation_warning:
+        note_lines.append(f"Subtotal-advarsel: {validation_warning}")
+    if line_sum is not None or subtotal is not None or difference is not None:
+        note_lines.append(
+            f"Beregnet linjesum: {line_sum if line_sum is not None else '-'} · Subtotal: {subtotal if subtotal is not None else '-'} · Afvigelse: {difference if difference is not None else '-'}"
+        )
+    if vat_warning:
+        note_lines.append(f"Moms-advarsel: {vat_warning}")
+    if vat_amount is not None or vat_expected is not None or vat_difference is not None:
+        note_lines.append(
+            f"Registreret moms: {vat_amount if vat_amount is not None else '-'} · Forventet moms: {vat_expected if vat_expected is not None else '-'} · Afvigelse: {vat_difference if vat_difference is not None else '-'}"
+        )
+
+    note_body = "\n".join(note_lines)
+    try:
+        existing = execute_query_single(
+            """
+            SELECT id
+            FROM sag_kommentarer
+            WHERE sag_id = %s
+              AND indhold = %s
+            ORDER BY id DESC
+            LIMIT 1
+            """,
+            (sag_id, note_body),
+        )
+        if existing:
+            return
+
+        execute_update(
+            """
+            INSERT INTO sag_kommentarer (sag_id, forfatter, indhold, er_system_besked)
+            VALUES (%s, %s, %s, %s)
+            """,
+            (sag_id, "Invoice Bot", note_body, True),
+        )
+    except Exception as comment_error:
+        logger.warning(
+            "⚠️ Could not persist amount validation case note for supplier invoice %s / SAG-%s: %s",
+            invoice_id,
+            sag_id,
+            comment_error,
+        )
+
+
 def _to_decimal(value, default: Decimal = Decimal("0")) -> Decimal:
     if value is None or value == "":
         return default
@@ -328,6 +508,39 @@ def _to_decimal(value, default: Decimal = Decimal("0")) -> Decimal:
         return default
 
 
+def _normalize_change_value(value):
+    if isinstance(value, Decimal):
+        return str(value.quantize(Decimal("0.01")))
+    if isinstance(value, float):
+        return f"{value:.2f}"
+    if isinstance(value, (datetime, date)):
+        return value.isoformat()
+    if value is None:
+        return None
+    text = str(value).strip()
+    return text or None
+
+
+def _append_connection_history(connection_id: int, event_type: str, summary: str, details: Dict) -> None:
+    execute_update(
+        """
+        INSERT INTO internet_connections_history (connection_id, event_type, summary, details)
+        VALUES (%s, %s, %s, %s::jsonb)
+        """,
+        (connection_id, event_type, summary, json.dumps(details or {})),
+    )
+
+
+def _build_change_dict(existing: Dict, updated: Dict, fields: List[str]) -> Dict[str, Dict[str, object]]:
+    changes: Dict[str, Dict[str, object]] = {}
+    for field in fields:
+        before = _normalize_change_value(existing.get(field))
+        after = _normalize_change_value(updated.get(field))
+        if before != after:
+            changes[field] = {"from": before, "to": after}
+    return changes
+
+
 def _extract_lines_from_llm_payload(extraction_row: Optional[Dict]) -> List[Dict]:
     if not extraction_row:
         return []
@@ -359,6 +572,18 @@ def _extract_lines_from_llm_payload(extraction_row: Optional[Dict]) -> List[Dict
                 "line_total": line.get("line_total") or line.get("amount") or 0,
                 "vat_rate": line.get("vat_rate") or 25.0,
                 "vat_amount": line.get("vat_amount") or 0,
+                "ip_address": line.get("ip_address"),
+                "contract_number": line.get("contract_number"),
+                "provider_reference": line.get("provider_reference"),
+                "customer_reference": line.get("customer_reference"),
+                "circuit_id": line.get("circuit_id"),
+                "end_customer_name": line.get("end_customer_name"),
+                "period_start": line.get("period_start"),
+                "period_end": line.get("period_end"),
+                "service_address": line.get("service_address"),
+                "location_street": line.get("location_street"),
+                "location_zip": line.get("location_zip"),
+                "location_city": line.get("location_city"),
             }
         )
     return normalized
@@ -373,7 +598,11 @@ def _load_extraction_lines(extraction_row: Optional[Dict]) -> List[Dict]:
 
     db_lines = execute_query(
         """
-        SELECT line_number, sku, description, quantity, unit_price, line_total, vat_rate, vat_amount
+        SELECT
+            line_number, sku, description, quantity, unit_price, line_total, vat_rate, vat_amount,
+            ip_address, contract_number, provider_reference, customer_reference, circuit_id,
+            end_customer_name, period_start, period_end, service_address,
+            location_street, location_zip, location_city
         FROM extraction_lines
         WHERE extraction_id = %s
         ORDER BY line_number
@@ -387,6 +616,1127 @@ def _load_extraction_lines(extraction_row: Optional[Dict]) -> List[Dict]:
     return _extract_lines_from_llm_payload(extraction_row)
 
 
+def _compose_supplier_line_description(line: Dict) -> str:
+    description = str(line.get("description") or "").strip()
+    extras = []
+    for key in ("provider_reference", "circuit_id", "contract_number"):
+        value = str(line.get(key) or "").strip()
+        if value and value not in extras:
+            extras.append(value)
+
+    if line.get("service_address"):
+        extras.append(str(line.get("service_address")).strip())
+    elif line.get("location_street") and line.get("location_zip") and line.get("location_city"):
+        extras.append(f"{line.get('location_street')}, {line.get('location_zip')} {line.get('location_city')}")
+
+    if line.get("period_start") and line.get("period_end"):
+        extras.append(f"{line.get('period_start')} til {line.get('period_end')}")
+
+    if not extras:
+        return description
+    return f"{description} ({' · '.join(extras)})"
+
+
+def _is_globalconnect_extraction(extraction_row: Optional[Dict]) -> bool:
+    if not extraction_row:
+        return False
+    vendor_name = str(extraction_row.get("vendor_name") or "").lower()
+    if "globalconnect" in vendor_name:
+        return True
+
+    try:
+        payload = extraction_row.get("llm_response_json")
+        if isinstance(payload, str):
+            payload = json.loads(payload)
+        issuer = str((payload or {}).get("issuer") or "").lower()
+        template = str((payload or {}).get("template") or "").lower()
+        return "globalconnect" in issuer or template == "dk.globalconnect"
+    except Exception:
+        return False
+
+
+def _normalize_company_name(value: Optional[str]) -> str:
+    normalized = str(value or "").upper()
+    replacements = {
+        "Æ": "AE",
+        "Ø": "OE",
+        "Å": "AA",
+        "&": " OG ",
+        "/": " ",
+    }
+    for source, target in replacements.items():
+        normalized = normalized.replace(source, target)
+    normalized = re.sub(r"[^A-Z0-9 ]+", " ", normalized)
+    normalized = re.sub(r"\s+", " ", normalized).strip()
+    return normalized
+
+
+def _build_service_address(line: Dict) -> Optional[str]:
+    if line.get("service_address"):
+        return str(line.get("service_address")).strip()
+    if line.get("location_street") and line.get("location_zip") and line.get("location_city"):
+        return f"{line.get('location_street')}, {line.get('location_zip')} {line.get('location_city')}"
+    return None
+
+
+def _normalize_provider_reference(value: Optional[str]) -> str:
+    raw = str(value or "").strip().upper()
+    if not raw:
+        return ""
+    return re.sub(r"[^A-Z0-9]", "", raw)
+
+
+def _build_mapping_note(end_customer_name: str, service_address: Optional[str], reference: str) -> str:
+    parts = [f"Afventer mapping for {reference}."]
+    if end_customer_name:
+        parts.append(f"Udtrukket kunde: {end_customer_name}.")
+    if service_address:
+        parts.append(f"Udtrukket adresse: {service_address}.")
+    parts.append("Kræver manuel kontrol før forbindelsen kan anses som korrekt.")
+    return " ".join(parts)
+
+
+def _has_confident_globalconnect_mapping(matched_customer: Optional[Dict], service_address: Optional[str]) -> bool:
+    return bool(matched_customer and service_address)
+
+
+def _resolve_internal_bmc_customer() -> Optional[Dict]:
+    preferred = execute_query_single(
+        """
+        SELECT id, name, address, postal_code, city
+        FROM customers
+        WHERE is_active = true
+          AND lower(name) = %s
+        """,
+        ("bmc networks",),
+    )
+    if preferred:
+        return dict(preferred)
+
+    try:
+        customer_id = _resolve_procurement_customer_id()
+    except Exception:
+        return None
+
+    fallback = execute_query_single(
+        """
+        SELECT id, name, address, postal_code, city
+        FROM customers
+        WHERE id = %s AND is_active = true
+        """,
+        (customer_id,),
+    )
+    return dict(fallback) if fallback else None
+
+
+def _should_assign_internal_bmc_owner(
+    lines: List[Dict],
+    matched_customer: Optional[Dict],
+    service_address: Optional[str],
+) -> bool:
+    if matched_customer:
+        return False
+    if any(str(line.get("end_customer_name") or "").strip() for line in lines):
+        return False
+    if any(_looks_like_ip_range_line(line) for line in lines):
+        return True
+    if len(lines) > 1:
+        return True
+    return bool(service_address)
+
+
+def _shared_connection_value_type(internal_owner: Optional[Dict], matched_customer: Optional[Dict]) -> str:
+    if internal_owner and not matched_customer:
+        return "delefiber"
+    return "other"
+
+
+def _load_active_customers_for_matching() -> List[Dict]:
+    rows = execute_query(
+        """
+        SELECT id, name, address, postal_code, city
+        FROM customers
+        WHERE is_active = true
+        ORDER BY id
+        """
+    ) or []
+    return [dict(row) for row in rows]
+
+
+def _match_customer_for_globalconnect_line(line: Dict, customers: List[Dict]) -> Optional[Dict]:
+    end_customer_name = str(line.get("end_customer_name") or "").strip()
+    service_address = _build_service_address(line) or ""
+    normalized_target = _normalize_company_name(end_customer_name)
+    address_parts = [part.strip().upper() for part in re.split(r"[, ]+", service_address) if part.strip()]
+
+    best_match = None
+    best_score = 0
+    for customer in customers:
+        customer_name = str(customer.get("name") or "").strip()
+        normalized_customer = _normalize_company_name(customer_name)
+        score = 0
+
+        if normalized_target and normalized_customer:
+            if normalized_target == normalized_customer:
+                score = 100
+            elif normalized_target in normalized_customer or normalized_customer in normalized_target:
+                score = 80
+            else:
+                target_tokens = set(normalized_target.split())
+                customer_tokens = set(normalized_customer.split())
+                overlap = target_tokens & customer_tokens
+                if overlap:
+                    score = max(score, min(len(overlap) * 15, 60))
+
+        if service_address:
+            customer_address = str(customer.get("address") or "").upper()
+            customer_city = str(customer.get("city") or "").upper()
+            customer_postal = str(customer.get("postal_code") or "").upper()
+            address_score = 0
+            if customer_address and customer_address in service_address.upper():
+                address_score += 35
+            if customer_city and customer_city in service_address.upper():
+                address_score += 20
+            if customer_postal and customer_postal in service_address.upper():
+                address_score += 20
+            if address_parts and customer_address:
+                overlap = sum(1 for part in address_parts if len(part) > 2 and part in customer_address)
+                address_score += min(overlap * 5, 15)
+            score = max(score, address_score)
+
+        if score > best_score:
+            best_score = score
+            best_match = customer
+
+    return best_match if best_score >= 50 else None
+
+
+def _looks_like_ip_range_line(line: Dict) -> bool:
+    description = str(line.get("description") or "").lower()
+    return bool(line.get("ip_address")) and (
+        "ipv4" in description
+        or "ipv6" in description
+        or "ip-adress" in description
+        or "ip adress" in description
+    )
+
+
+def _looks_like_connection_component(line: Dict) -> bool:
+    if _looks_like_ip_range_line(line):
+        return False
+    reference = _normalize_provider_reference(line.get("provider_reference") or line.get("circuit_id"))
+    if not reference:
+        return False
+    description = str(line.get("description") or "").lower()
+    if not description:
+        return False
+    return any(
+        token in description
+        for token in (
+            "fiber",
+            "adsl",
+            "vdsl",
+            "dsl",
+            "internet",
+            "mpls",
+            "rackskab",
+            "datacenter",
+            "sla",
+            "forbindelse",
+        )
+    )
+
+
+def _can_create_connection_from_line(line: Dict) -> bool:
+    if not _looks_like_connection_component(line):
+        return False
+    service_address = _build_service_address(line)
+    if not service_address:
+        return False
+    description = str(line.get("description") or "")
+    speed_mbps, upload_mbps, download_mbps = _infer_speed_profile(description)
+    return bool(speed_mbps or upload_mbps or download_mbps)
+
+
+def _infer_connection_type(description: str) -> str:
+    desc = description.lower()
+    if "mpls" in desc:
+        return "mpls"
+    if "rackskab" in desc or "datacenter" in desc:
+        return "datacenter"
+    if "adsl" in desc or "vdsl" in desc or "dsl" in desc:
+        return "xdsl"
+    return "fiber"
+
+
+def _infer_technology(description: str) -> str:
+    desc = description.lower()
+    if "adsl" in desc:
+        return "ADSL"
+    if "vdsl" in desc:
+        return "VDSL"
+    if "mpls" in desc:
+        return "MPLS"
+    if "fiber" in desc:
+        return "Fiber"
+    if "datacenter" in desc:
+        return "Datacenter"
+    return "Internet"
+
+
+def _infer_speed_profile(description: str) -> tuple[Optional[int], Optional[int], Optional[int]]:
+    slash_match = re.search(
+        r"(\d+(?:[.,]\d+)?)\s*/\s*(\d+(?:[.,]\d+)?)\s*(K|M|G)bps",
+        description,
+        re.IGNORECASE,
+    )
+    if slash_match:
+        down_value = float(slash_match.group(1).replace(",", "."))
+        up_value = float(slash_match.group(2).replace(",", "."))
+        unit = slash_match.group(3).upper()
+        multiplier = 1
+        if unit == "G":
+            multiplier = 1000
+        elif unit == "K":
+            multiplier = 1 / 1000
+
+        download_mbps = max(int(round(down_value * multiplier)), 1)
+        upload_mbps = max(int(round(up_value * multiplier)), 1)
+        return download_mbps, upload_mbps, download_mbps
+
+    match = re.search(r"(\d+(?:[.,]\d+)?)\s*(G|M)bps", description, re.IGNORECASE)
+    if not match:
+        return None, None, None
+    value = float(match.group(1).replace(",", "."))
+    unit = match.group(2).upper()
+    speed_mbps = int(value * 1000) if unit == "G" else int(value)
+    return speed_mbps, speed_mbps, speed_mbps
+
+
+def _line_monthly_cost(line: Dict) -> Decimal:
+    unit_price = _to_decimal(line.get("unit_price"))
+    if unit_price > 0:
+        return unit_price
+
+    line_total = _to_decimal(line.get("line_total"))
+    quantity = _to_decimal(line.get("quantity"), Decimal("1"))
+    if quantity <= 0:
+        return line_total
+    return line_total / quantity
+
+
+def _ensure_connection_pricing_entry(connection_id: int, effective_from, purchase_price: Decimal, notes: str):
+    if not effective_from:
+        return
+    existing = execute_query_single(
+        """
+        SELECT id
+        FROM internet_connections_pricing
+        WHERE connection_id = %s AND effective_from = %s
+        ORDER BY id DESC
+        LIMIT 1
+        """,
+        (connection_id, effective_from),
+    )
+    if existing:
+        execute_update(
+            """
+            UPDATE internet_connections_pricing
+            SET purchase_price = %s,
+                notes = %s
+            WHERE id = %s
+            """,
+            (purchase_price, notes, existing["id"]),
+        )
+        return
+
+    execute_update(
+        """
+        INSERT INTO internet_connections_pricing (
+            connection_id, effective_from, purchase_price, sales_price, notes
+        )
+        VALUES (%s, %s, %s, %s, %s)
+        """,
+        (connection_id, effective_from, purchase_price, Decimal("0"), notes),
+    )
+
+
+def _ensure_ip_addresses_for_range(range_id: int, cidr: str) -> int:
+    existing = execute_query_single(
+        """
+        SELECT COUNT(*) AS total
+        FROM internet_connections_ip_addresses
+        WHERE range_id = %s AND deleted_at IS NULL
+        """,
+        (range_id,),
+    )
+    if existing and int(existing.get("total") or 0) > 0:
+        return int(existing.get("total") or 0)
+
+    try:
+        network = ipaddress.ip_network(cidr, strict=False)
+    except ValueError:
+        return 0
+
+    created = 0
+    for host in network.hosts():
+        existing_ip = execute_query_single(
+            """
+            SELECT id
+            FROM internet_connections_ip_addresses
+            WHERE ip_address = %s
+              AND deleted_at IS NULL
+            LIMIT 1
+            """,
+            (str(host),),
+        )
+        if existing_ip:
+            continue
+        execute_update(
+            """
+            INSERT INTO internet_connections_ip_addresses (
+                range_id, ip_address, status, assigned_to, assigned_type, comment
+            )
+            VALUES (%s, %s, %s, %s, %s, %s)
+            """,
+            (range_id, str(host), "available", None, None, "Auto-generated from synced CIDR"),
+        )
+        created += 1
+    return created
+
+
+def _merge_globalconnect_duplicate_connections(connection_ids: List[int], canonical_id: int):
+    duplicate_ids = [connection_id for connection_id in connection_ids if connection_id != canonical_id]
+    if not duplicate_ids:
+        return
+
+    for duplicate_id in duplicate_ids:
+        execute_update(
+            """
+            UPDATE internet_connections_ip_ranges
+            SET connection_id = %s,
+                updated_at = CURRENT_TIMESTAMP
+            WHERE connection_id = %s AND deleted_at IS NULL
+            """,
+            (canonical_id, duplicate_id),
+        )
+        execute_update(
+            """
+            UPDATE internet_connections_ip_addresses
+            SET assigned_connection_id = %s
+            WHERE assigned_connection_id = %s
+            """,
+            (canonical_id, duplicate_id),
+        )
+        execute_update(
+            """
+            UPDATE internet_connections_connections
+            SET deleted_at = CURRENT_TIMESTAMP,
+                updated_at = CURRENT_TIMESTAMP,
+                notes = CONCAT(COALESCE(notes, ''), CASE WHEN COALESCE(notes, '') = '' THEN '' ELSE E'\n' END, %s)
+            WHERE id = %s
+            """,
+            (f"Dublet samlet under forbindelse #{canonical_id} via GlobalConnect reference-normalisering.", duplicate_id),
+        )
+
+
+def _merge_globalconnect_duplicate_ip_ranges(connection_id: int, cidr: str) -> Optional[int]:
+    matches = execute_query(
+        """
+        SELECT id
+        FROM internet_connections_ip_ranges
+        WHERE connection_id = %s
+          AND cidr = %s
+          AND deleted_at IS NULL
+        ORDER BY id
+        """,
+        (connection_id, cidr),
+    )
+    if not matches:
+        return None
+
+    canonical_id = int(matches[0]["id"])
+    duplicate_ids = [int(row["id"]) for row in matches[1:]]
+    for duplicate_id in duplicate_ids:
+        execute_update(
+            """
+            UPDATE internet_connections_ip_addresses
+            SET range_id = %s
+            WHERE range_id = %s
+            """,
+            (canonical_id, duplicate_id),
+        )
+        execute_update(
+            """
+            UPDATE internet_connections_ip_ranges
+            SET deleted_at = CURRENT_TIMESTAMP,
+                updated_at = CURRENT_TIMESTAMP,
+                description = CONCAT(COALESCE(description, ''), CASE WHEN COALESCE(description, '') = '' THEN '' ELSE E'\n' END, %s)
+            WHERE id = %s
+            """,
+            (f"Dublet samlet under range #{canonical_id} via GlobalConnect reference-normalisering.", duplicate_id),
+        )
+    return canonical_id
+
+
+def _normalize_service_address_for_match(value: Optional[str]) -> str:
+    normalized = str(value or "").strip().upper()
+    normalized = normalized.replace("Æ", "AE").replace("Ø", "OE").replace("Å", "AA")
+    normalized = re.sub(r"[^A-Z0-9]", "", normalized)
+    return normalized
+
+
+def _get_globalconnect_connections_by_reference(reference: str) -> List[Dict]:
+    if not reference:
+        return []
+    rows = execute_query(
+        """
+        SELECT id, customer_id, address, monthly_cost, technology, connection_type,
+               circuit_number, speed_mbps, download_mbps, upload_mbps, status,
+               allocation_model, value_type, value_label
+        FROM internet_connections_connections
+        WHERE deleted_at IS NULL
+          AND provider ILIKE 'GlobalConnect%%'
+          AND regexp_replace(UPPER(COALESCE(circuit_number, '')), '[^A-Z0-9]', '', 'g') = %s
+        ORDER BY id
+        """,
+        (reference,),
+    ) or []
+    return [dict(row) for row in rows]
+
+
+def _resolve_existing_globalconnect_connection(reference: str, service_address: Optional[str]) -> Dict[str, object]:
+    matches = _get_globalconnect_connections_by_reference(reference)
+    if not matches:
+        return {"row": None, "merge_ids": [], "conflict_reason": None, "matched_on": None}
+
+    normalized_target = _normalize_service_address_for_match(service_address)
+    exact_matches = []
+    blank_address_matches = []
+    other_address_matches = []
+
+    for row in matches:
+        normalized_existing = _normalize_service_address_for_match(row.get("address"))
+        if not normalized_existing:
+            blank_address_matches.append(row)
+        elif normalized_existing == normalized_target:
+            exact_matches.append(row)
+        else:
+            other_address_matches.append(row)
+
+    if exact_matches:
+        canonical = exact_matches[0]
+        merge_ids = [int(row["id"]) for row in exact_matches[1:] + blank_address_matches]
+        return {
+            "row": canonical,
+            "merge_ids": merge_ids,
+            "conflict_reason": None,
+            "matched_on": "address",
+        }
+
+    if blank_address_matches and not other_address_matches:
+        canonical = blank_address_matches[0]
+        merge_ids = [int(row["id"]) for row in blank_address_matches[1:]]
+        return {
+            "row": canonical,
+            "merge_ids": merge_ids,
+            "conflict_reason": None,
+            "matched_on": "blank_address",
+        }
+
+    conflicting_addresses = ", ".join(
+        sorted({str(row.get("address") or "").strip() for row in other_address_matches if str(row.get("address") or "").strip()})
+    )
+    conflict_reason = "Reference findes allerede på anden adresse"
+    if conflicting_addresses:
+        conflict_reason = f"{conflict_reason}: {conflicting_addresses}"
+    return {"row": None, "merge_ids": [], "conflict_reason": conflict_reason, "matched_on": None}
+
+
+def _upsert_globalconnect_connection(reference: str, lines: List[Dict], invoice_date, invoice_number: str, customers: List[Dict]) -> Optional[int]:
+    if not reference or not lines:
+        return None
+
+    sorted_lines = sorted(
+        lines,
+        key=lambda item: (
+            "administrationsgebyr" in str(item.get("description") or "").lower(),
+            "sla" in str(item.get("description") or "").lower(),
+        ),
+    )
+    primary_line = sorted_lines[0]
+    display_reference = str(primary_line.get("provider_reference") or primary_line.get("circuit_id") or reference).strip()
+    matched_customer = _match_customer_for_globalconnect_line(primary_line, customers)
+    service_address = _build_service_address(primary_line)
+    if not service_address:
+        logger.warning(
+            "Skipping GlobalConnect connection %s from invoice %s because service address is missing",
+            display_reference or reference,
+            invoice_number,
+        )
+        return None
+    description = str(primary_line.get("description") or reference)
+    end_customer_name = str(primary_line.get("end_customer_name") or "").strip()
+    internal_owner = _resolve_internal_bmc_customer() if _should_assign_internal_bmc_owner(lines, matched_customer, service_address) else None
+    owner_customer = matched_customer or internal_owner
+    is_confident = _has_confident_globalconnect_mapping(matched_customer, service_address)
+    connection_name = (
+        end_customer_name or service_address or f"GlobalConnect {reference}"
+        if is_confident
+        else (f"{internal_owner['name']} · {display_reference}" if internal_owner else f"Afventer mapping · {display_reference}")
+    )
+    monthly_cost = sum((_line_monthly_cost(line) for line in lines), Decimal("0"))
+    note_lines = ", ".join(dict.fromkeys(str(line.get("description") or "").strip() for line in lines if line.get("description")))
+    base_note = f"Synced fra GlobalConnect faktura {invoice_number}. Komponenter: {note_lines}"
+    mapping_note = _build_mapping_note(end_customer_name, service_address, display_reference)
+    if internal_owner and not matched_customer:
+        note_text = f"{base_note} Ejer sat til intern BMC-kunde, da forbindelsen bruges som delt hovedforbindelse eller ikke kan bindes sikkert til én slutkunde."
+    else:
+        note_text = base_note if is_confident else f"{base_note} {mapping_note}"
+
+    existing_resolution = _resolve_existing_globalconnect_connection(reference, service_address)
+    existing = existing_resolution.get("row")
+    conflict_reason = existing_resolution.get("conflict_reason")
+    if conflict_reason:
+        logger.warning(
+            "Skipping GlobalConnect connection %s from invoice %s because %s",
+            display_reference or reference,
+            invoice_number,
+            conflict_reason,
+        )
+        return None
+    merge_ids = [int(item) for item in (existing_resolution.get("merge_ids") or [])]
+    if existing and merge_ids:
+        _merge_globalconnect_duplicate_connections([int(existing["id"])] + merge_ids, int(existing["id"]))
+
+    download_mbps, upload_mbps, speed_mbps = _infer_speed_profile(description)
+    target_status = "active" if (is_confident or internal_owner) else "pending"
+    shared_value_type = _shared_connection_value_type(internal_owner, matched_customer)
+    payload = (
+        connection_name,
+        "GlobalConnect A/S",
+        owner_customer["id"] if owner_customer else None,
+        service_address,
+        monthly_cost,
+        _infer_technology(description),
+        _infer_connection_type(description),
+        display_reference,
+        speed_mbps,
+        upload_mbps,
+        download_mbps,
+        note_text,
+        "shared" if internal_owner and not matched_customer else "dedicated",
+        shared_value_type,
+        None,
+    )
+
+    if existing:
+        updated_snapshot = {
+            "customer_id": owner_customer["id"] if owner_customer else None,
+            "address": service_address,
+            "monthly_cost": monthly_cost,
+            "technology": _infer_technology(description),
+            "connection_type": _infer_connection_type(description),
+            "circuit_number": display_reference,
+            "speed_mbps": speed_mbps,
+            "download_mbps": download_mbps,
+            "upload_mbps": upload_mbps,
+            "status": target_status,
+            "allocation_model": "shared" if internal_owner and not matched_customer else "dedicated",
+            "value_type": shared_value_type,
+            "value_label": None,
+        }
+        update_payload = (
+            connection_name,
+            "GlobalConnect A/S",
+            owner_customer["id"] if owner_customer else None,
+            service_address,
+            monthly_cost,
+            _infer_technology(description),
+            _infer_connection_type(description),
+            display_reference,
+            speed_mbps,
+            download_mbps,
+            upload_mbps,
+            note_text,
+            "shared" if internal_owner and not matched_customer else "dedicated",
+            shared_value_type,
+            None,
+            existing["id"],
+        )
+        execute_update(
+            """
+            UPDATE internet_connections_connections
+            SET name = %s,
+                provider = %s,
+                customer_id = COALESCE(%s, customer_id),
+                address = COALESCE(%s, address),
+                status = %s,
+                monthly_cost = %s,
+                technology = %s,
+                connection_type = %s,
+                circuit_number = %s,
+                speed_mbps = COALESCE(%s, speed_mbps),
+                download_mbps = COALESCE(%s, download_mbps),
+                upload_mbps = COALESCE(%s, upload_mbps),
+                allocation_model = %s,
+                value_type = %s,
+                value_label = %s,
+                notes = %s,
+                updated_at = CURRENT_TIMESTAMP
+            WHERE id = %s
+            """,
+            (
+                update_payload[0],
+                update_payload[1],
+                update_payload[2],
+                update_payload[3],
+                "active" if (is_confident or internal_owner) else "pending",
+                update_payload[4],
+                update_payload[5],
+                update_payload[6],
+                update_payload[7],
+                update_payload[8],
+                update_payload[9],
+                update_payload[10],
+                update_payload[12],
+                update_payload[13],
+                update_payload[14],
+                update_payload[11],
+                update_payload[15],
+            ),
+        )
+        connection_id = int(existing["id"])
+        changes = _build_change_dict(
+            existing,
+            updated_snapshot,
+            [
+                "customer_id",
+                "address",
+                "monthly_cost",
+                "technology",
+                "connection_type",
+                "circuit_number",
+                "speed_mbps",
+                "download_mbps",
+                "upload_mbps",
+                "status",
+                "allocation_model",
+                "value_type",
+            ],
+        )
+        if changes:
+            _append_connection_history(
+                connection_id,
+                "supplier_invoice_sync_changed",
+                f"Opdateret fra GlobalConnect faktura {invoice_number}",
+                {"reference": display_reference, "changes": changes},
+            )
+            _ensure_internet_change_case(
+                connection_id=connection_id,
+                invoice_number=invoice_number,
+                reference=display_reference,
+                connection_name=connection_name,
+                owner_customer_id=owner_customer["id"] if owner_customer else None,
+                changes=changes,
+            )
+    else:
+        connection_id = execute_insert(
+            """
+            INSERT INTO internet_connections_connections (
+                name, provider, customer_id, address, status, monthly_cost, sales_price,
+                technology, connection_type, circuit_number, speed_mbps, upload_mbps,
+                download_mbps, notes, allocation_model, value_type, value_label
+            )
+            VALUES (%s, %s, %s, %s, %s, %s, 0, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+            RETURNING id
+            """,
+            (
+                payload[0],
+                payload[1],
+                payload[2],
+                payload[3],
+                "active" if (is_confident or internal_owner) else "pending",
+                payload[4],
+                payload[5],
+                payload[6],
+                payload[7],
+                payload[8],
+                payload[9],
+                payload[10],
+                payload[11],
+                payload[12],
+                payload[13],
+                payload[14],
+            ),
+        )
+        _append_connection_history(
+            connection_id,
+            "connection_created_from_supplier_invoice",
+            f"Oprettet fra GlobalConnect faktura {invoice_number}",
+            {"reference": display_reference, "normalized_reference": reference, "invoice_number": invoice_number},
+        )
+
+    _ensure_connection_pricing_entry(
+        connection_id=connection_id,
+        effective_from=invoice_date,
+        purchase_price=monthly_cost,
+        notes=f"GlobalConnect sync fra faktura {invoice_number}",
+    )
+    return int(connection_id)
+
+
+def _upsert_globalconnect_ip_range(connection_id: int, line: Dict, invoice_number: str):
+    cidr = str(line.get("ip_address") or "").strip()
+    if not connection_id or not cidr:
+        return None
+
+    display_reference = str(line.get("provider_reference") or line.get("circuit_id") or "").strip()
+    service_address = _build_service_address(line)
+    matched_customer = _match_customer_for_globalconnect_line(line, _load_active_customers_for_matching())
+    canonical_range_id = _merge_globalconnect_duplicate_ip_ranges(connection_id, cidr)
+    existing = execute_query_single(
+        """
+        SELECT id, provider_reference, contract_number, customer_id, service_address, monthly_cost
+        FROM internet_connections_ip_ranges
+        WHERE connection_id = %s AND cidr = %s AND deleted_at IS NULL
+        ORDER BY id
+        LIMIT 1
+        """,
+        (connection_id, cidr),
+    )
+    if not existing and canonical_range_id:
+        existing = {"id": canonical_range_id}
+    monthly_cost = _line_monthly_cost(line)
+    params = (
+        str(line.get("description") or "IP-range").strip(),
+        display_reference or None,
+        str(line.get("contract_number") or "").strip() or None,
+        matched_customer["id"] if matched_customer else None,
+        service_address,
+        monthly_cost,
+        Decimal("0"),
+    )
+
+    if existing:
+        changes = _build_change_dict(
+            existing,
+            {
+                "provider_reference": params[1],
+                "contract_number": params[2],
+                "customer_id": params[3],
+                "service_address": params[4],
+                "monthly_cost": params[5],
+            },
+            ["provider_reference", "contract_number", "customer_id", "service_address", "monthly_cost"],
+        )
+        execute_update(
+            """
+            UPDATE internet_connections_ip_ranges
+            SET name = %s,
+                provider_reference = %s,
+                contract_number = %s,
+                customer_id = COALESCE(%s, customer_id),
+                service_address = COALESCE(%s, service_address),
+                monthly_cost = %s,
+                sales_price = %s,
+                updated_at = CURRENT_TIMESTAMP
+            WHERE id = %s
+            """,
+            params + (existing["id"],),
+        )
+        range_id = int(existing["id"])
+        if service_address:
+            execute_update(
+                """
+                UPDATE internet_connections_connections
+                SET address = COALESCE(NULLIF(TRIM(address), ''), %s),
+                    updated_at = CURRENT_TIMESTAMP
+                WHERE id = %s
+                """,
+                (service_address, connection_id),
+            )
+        _ensure_ip_addresses_for_range(range_id, cidr)
+        if changes:
+            _append_connection_history(
+                connection_id,
+                "supplier_invoice_ip_range_changed",
+                f"IP-range {cidr} opdateret fra faktura {invoice_number}",
+                {"cidr": cidr, "changes": changes},
+            )
+            reference = display_reference or cidr
+            _ensure_internet_change_case(
+                connection_id=connection_id,
+                invoice_number=invoice_number,
+                reference=reference,
+                connection_name=f"IP-range {cidr}",
+                owner_customer_id=matched_customer["id"] if matched_customer else None,
+                changes=changes,
+            )
+        return range_id
+
+    range_id = execute_insert(
+        """
+        INSERT INTO internet_connections_ip_ranges (
+            connection_id, name, cidr, description, provider_reference, contract_number,
+            customer_id, service_address, monthly_cost, sales_price
+        )
+        VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+        RETURNING id
+        """,
+        (
+            connection_id,
+            params[0],
+            cidr,
+            f"Synced fra GlobalConnect faktura {invoice_number}",
+            params[1],
+            params[2],
+            params[3],
+            params[4],
+            params[5],
+            params[6],
+        ),
+    )
+    range_id = int(range_id)
+    if service_address:
+        execute_update(
+            """
+            UPDATE internet_connections_connections
+            SET address = COALESCE(NULLIF(TRIM(address), ''), %s),
+                updated_at = CURRENT_TIMESTAMP
+            WHERE id = %s
+            """,
+            (service_address, connection_id),
+        )
+    _ensure_ip_addresses_for_range(range_id, cidr)
+    _append_connection_history(
+        connection_id,
+        "supplier_invoice_ip_range_created",
+        f"IP-range {cidr} oprettet fra faktura {invoice_number}",
+        {"cidr": cidr, "provider_reference": params[1], "contract_number": params[2]},
+    )
+    return range_id
+
+
+def _find_existing_globalconnect_connection_id(reference: str, service_address: Optional[str]) -> tuple[Optional[int], Optional[str]]:
+    resolution = _resolve_existing_globalconnect_connection(reference, service_address)
+    existing = resolution.get("row")
+    if existing and existing.get("id"):
+        return int(existing["id"]), None
+    return None, resolution.get("conflict_reason")
+
+
+def _connection_can_host_ip_range(connection_id: Optional[int], service_address: Optional[str]) -> bool:
+    if not connection_id:
+        return False
+    row = execute_query_single(
+        """
+        SELECT address, allocation_model
+        FROM internet_connections_connections
+        WHERE id = %s
+          AND deleted_at IS NULL
+        """,
+        (connection_id,),
+    )
+    if not row:
+        return False
+    if str(row.get("allocation_model") or "").lower() == "shared":
+        return True
+    if not service_address:
+        return True
+    return _normalize_service_address_for_match(row.get("address")) == _normalize_service_address_for_match(service_address)
+
+
+def _connection_skip_reason(line: Dict) -> str:
+    reference = _normalize_provider_reference(line.get("provider_reference") or line.get("circuit_id"))
+    if not reference:
+        return "Mangler provider-reference/kredsløb"
+    if not _build_service_address(line):
+        return "Mangler serviceadresse"
+    description = str(line.get("description") or "")
+    speed_mbps, upload_mbps, download_mbps = _infer_speed_profile(description)
+    if not any((speed_mbps, upload_mbps, download_mbps)):
+        return "Mangler hastighed på forbindelseslinjen"
+    return "Forbindelseslinje kunne ikke valideres"
+
+
+def _build_sync_audit_entry(line: Dict, classification: str, status: str, reason: Optional[str] = None) -> Dict:
+    reference = str(line.get("provider_reference") or line.get("circuit_id") or "").strip()
+    return {
+        "line_number": line.get("line_number"),
+        "description": str(line.get("description") or "").strip() or "-",
+        "classification": classification,
+        "status": status,
+        "reason": reason,
+        "provider_reference": reference or None,
+        "ip_address": str(line.get("ip_address") or "").strip() or None,
+        "service_address": _build_service_address(line),
+        "end_customer_name": str(line.get("end_customer_name") or "").strip() or None,
+    }
+
+
+def _summarize_sync_audit(line_audit: List[Dict], connection_groups: int, ip_range_candidates: int) -> Dict:
+    actionable_lines = [entry for entry in line_audit if entry["classification"] in {"connection", "ip_range"}]
+    synced_lines = [entry for entry in actionable_lines if entry["status"] == "synced"]
+    skipped_lines = [entry for entry in actionable_lines if entry["status"] == "skipped"]
+    ignored_lines = [entry for entry in line_audit if entry["status"] == "ignored"]
+    return {
+        "total_lines": len(line_audit),
+        "actionable_lines": len(actionable_lines),
+        "synced_actionable_lines": len(synced_lines),
+        "skipped_actionable_lines": len(skipped_lines),
+        "ignored_lines": len(ignored_lines),
+        "connection_groups": connection_groups,
+        "ip_range_candidates": ip_range_candidates,
+        "all_actionable_accounted_for": len(actionable_lines) == (len(synced_lines) + len(skipped_lines)),
+        "fully_synced": len(skipped_lines) == 0 and len(actionable_lines) > 0,
+        "requires_manual_review": len(skipped_lines) > 0,
+    }
+
+
+def _sync_globalconnect_extraction_to_internet(extraction_row: Dict, simulate: bool = False) -> Dict:
+    if not _is_globalconnect_extraction(extraction_row):
+        return {"skipped": True, "reason": "not_globalconnect"}
+
+    lines = _load_extraction_lines(extraction_row)
+    if not lines:
+        return {"skipped": True, "reason": "no_lines"}
+
+    invoice_number = str(extraction_row.get("document_id") or extraction_row.get("invoice_number") or extraction_row.get("file_id") or "ukendt")
+    invoice_date = extraction_row.get("document_date")
+    customers = _load_active_customers_for_matching()
+
+    grouped_connections: Dict[str, List[Dict]] = {}
+    connection_entry_indexes: Dict[str, List[int]] = {}
+    ip_range_lines: List[tuple[int, Dict]] = []
+    skipped_connection_lines = 0
+    line_audit: List[Dict] = []
+    for line in lines:
+        if _looks_like_ip_range_line(line):
+            line_audit.append(_build_sync_audit_entry(line, "ip_range", "pending"))
+            ip_range_lines.append((len(line_audit) - 1, line))
+            continue
+        if _looks_like_connection_component(line):
+            if not _can_create_connection_from_line(line):
+                skipped_connection_lines += 1
+                line_audit.append(_build_sync_audit_entry(line, "connection", "skipped", _connection_skip_reason(line)))
+                continue
+            reference = _normalize_provider_reference(line.get("provider_reference") or line.get("circuit_id"))
+            if reference:
+                grouped_connections.setdefault(reference, []).append(line)
+                line_audit.append(_build_sync_audit_entry(line, "connection", "pending"))
+                connection_entry_indexes.setdefault(reference, []).append(len(line_audit) - 1)
+            else:
+                skipped_connection_lines += 1
+                line_audit.append(_build_sync_audit_entry(line, "connection", "skipped", "Mangler provider-reference/kredsløb"))
+            continue
+        line_audit.append(_build_sync_audit_entry(line, "other", "ignored", "Ikke en forbindelses- eller IP-range-linje"))
+
+    connection_map: Dict[str, int] = {}
+    created_or_updated_connections = 0
+    created_connections = 0
+    updated_connections = 0
+    for reference, reference_lines in grouped_connections.items():
+        primary_line = reference_lines[0]
+        service_address = _build_service_address(primary_line)
+        existing_connection_id, connection_conflict_reason = _find_existing_globalconnect_connection_id(reference, service_address)
+        if connection_conflict_reason:
+            for index in connection_entry_indexes.get(reference, []):
+                line_audit[index]["status"] = "skipped"
+                line_audit[index]["reason"] = connection_conflict_reason
+            skipped_connection_lines += len(connection_entry_indexes.get(reference, []))
+            continue
+        if simulate:
+            connection_id = existing_connection_id or -(len(connection_map) + 1)
+        else:
+            connection_id = _upsert_globalconnect_connection(
+                reference=reference,
+                lines=reference_lines,
+                invoice_date=invoice_date,
+                invoice_number=invoice_number,
+                customers=customers,
+            )
+        if connection_id:
+            connection_map[reference] = connection_id
+            created_or_updated_connections += 1
+            if existing_connection_id:
+                updated_connections += 1
+                outcome = "updated"
+            else:
+                created_connections += 1
+                outcome = "created"
+            for index in connection_entry_indexes.get(reference, []):
+                line_audit[index]["status"] = "synced"
+                line_audit[index]["result"] = outcome
+                line_audit[index]["connection_id"] = None if simulate else connection_id
+        else:
+            for index in connection_entry_indexes.get(reference, []):
+                line_audit[index]["status"] = "skipped"
+                line_audit[index]["reason"] = "Forbindelsen kunne ikke oprettes/opdateres"
+
+    created_or_updated_ranges = 0
+    synced_ip_ranges_existing_connection = 0
+    skipped_orphan_ip_ranges = 0
+    for audit_index, line in ip_range_lines:
+        reference = _normalize_provider_reference(line.get("provider_reference") or line.get("circuit_id"))
+        service_address = _build_service_address(line)
+        connection_id = connection_map.get(reference)
+        resolved_from_existing = False
+        if connection_id and not _connection_can_host_ip_range(connection_id, service_address):
+            connection_id = None
+        if not connection_id and reference:
+            if not service_address:
+                line_audit[audit_index]["status"] = "skipped"
+                line_audit[audit_index]["reason"] = "Mangler serviceadresse til IP-range"
+                skipped_orphan_ip_ranges += 1
+                continue
+            connection_id, connection_conflict_reason = _find_existing_globalconnect_connection_id(reference, service_address)
+            if connection_id:
+                connection_map[reference] = connection_id
+                resolved_from_existing = True
+            elif connection_conflict_reason:
+                skipped_orphan_ip_ranges += 1
+                line_audit[audit_index]["status"] = "skipped"
+                line_audit[audit_index]["reason"] = connection_conflict_reason
+                continue
+
+        if connection_id and (
+            simulate
+            or _upsert_globalconnect_ip_range(connection_id, line, invoice_number)
+        ):
+            created_or_updated_ranges += 1
+            if resolved_from_existing:
+                synced_ip_ranges_existing_connection += 1
+            line_audit[audit_index]["status"] = "synced"
+            line_audit[audit_index]["result"] = "linked_existing_connection" if resolved_from_existing else "linked_synced_connection"
+            line_audit[audit_index]["connection_id"] = None if simulate else connection_id
+        elif not connection_id:
+            skipped_orphan_ip_ranges += 1
+            line_audit[audit_index]["status"] = "skipped"
+            line_audit[audit_index]["reason"] = "Ingen forbindelse fundet til IP-range"
+
+    verification = _summarize_sync_audit(
+        line_audit=line_audit,
+        connection_groups=len(grouped_connections),
+        ip_range_candidates=len(ip_range_lines),
+    )
+
+    return {
+        "skipped": False,
+        "simulate": simulate,
+        "connections_synced": created_or_updated_connections,
+        "connections_created": created_connections,
+        "connections_updated": updated_connections,
+        "ip_ranges_synced": created_or_updated_ranges,
+        "ip_ranges_linked_existing_connections": synced_ip_ranges_existing_connection,
+        "skipped_connection_lines": skipped_connection_lines,
+        "skipped_orphan_ip_ranges": skipped_orphan_ip_ranges,
+        "line_audit": line_audit,
+        "skipped_items": [entry for entry in line_audit if entry["status"] == "skipped"],
+        "verification": verification,
+    }
+
+
 def _find_existing_product_id(vendor_id: Optional[int], description: str, sku: Optional[str]) -> Optional[int]:
     sku_value = str(sku or "").strip()
     desc_value = str(description or "").strip()
@@ -1035,7 +2385,13 @@ async def get_file_extracted_data(file_id: int):
                     "unit_price": float(line.get('unit_price')) if line.get('unit_price') else None,
                     "vat_rate": float(line.get('vat_rate')) if line.get('vat_rate') else None,
                     "line_total": float(line.get('line_total')) if line.get('line_total') else None,
-                    "vat_note": line.get('vat_note')
+                    "vat_note": line.get('vat_note'),
+                    "provider_reference": line.get('provider_reference'),
+                    "contract_number": line.get('contract_number'),
+                    "circuit_id": line.get('circuit_id'),
+                    "ip_address": line.get('ip_address'),
+                    "end_customer_name": line.get('end_customer_name'),
+                    "service_address": line.get('service_address'),
                 })
         elif llm_json_data and llm_json_data.get('lines'):
             # Use lines from LLM JSON response
@@ -1046,7 +2402,13 @@ async def get_file_extracted_data(file_id: int):
                     "unit_price": float(line.get('unit_price')) if line.get('unit_price') else None,
                     "vat_rate": float(line.get('vat_rate')) if line.get('vat_rate') else None,
                     "line_total": float(line.get('line_total')) if line.get('line_total') else None,
-                    "vat_note": line.get('vat_note')
+                    "vat_note": line.get('vat_note'),
+                    "provider_reference": line.get('provider_reference'),
+                    "contract_number": line.get('contract_number'),
+                    "circuit_id": line.get('circuit_id'),
+                    "ip_address": line.get('ip_address'),
+                    "end_customer_name": line.get('end_customer_name'),
+                    "service_address": line.get('service_address'),
                 })
         
         # Build llm_data response
@@ -1099,7 +2461,10 @@ async def get_file_extracted_data(file_id: int):
                 "vendor_city": vendor_city_val,
                 "vendor_postal_code": vendor_postal_val,
                 "vendor_email": vendor_email_val,
-                "lines": formatted_lines
+                "lines": formatted_lines,
+                "_validation_warning": llm_json_data.get('_validation_warning'),
+                "_vat_warning": llm_json_data.get('_vat_warning'),
+                "_validation_details": llm_json_data.get('_validation_details'),
             }
         elif extraction:
             # Fallback to extraction table columns if no LLM JSON
@@ -1121,6 +2486,12 @@ async def get_file_extracted_data(file_id: int):
         
         # Get vendor from extraction
         vendor_matched_id = extraction.get('vendor_matched_id') if extraction else None
+        internet_sync_preview = None
+        if extraction:
+            try:
+                internet_sync_preview = _sync_globalconnect_extraction_to_internet(extraction, simulate=True)
+            except Exception as preview_error:
+                logger.warning("⚠️ Could not build internet sync preview for file %s: %s", file_id, preview_error)
         
         return {
             "file_id": file_id,
@@ -1131,6 +2502,7 @@ async def get_file_extracted_data(file_id: int):
             "llm_data": llm_data,
             "extraction": extraction,
             "extraction_lines": extraction_lines if extraction_lines else [],
+            "internet_sync_preview": internet_sync_preview,
             "pdf_text_preview": pdf_text[:5000] if pdf_text else None
         }
         
@@ -1321,13 +2693,22 @@ async def link_vendor_to_extraction(file_id: int, data: dict):
             "UPDATE incoming_files SET detected_vendor_id = %s, status = 'processed' WHERE file_id = %s",
             (vendor_id, file_id)
         )
+
+        sync_result = None
+        extraction_row = execute_query_single(
+            "SELECT * FROM extractions WHERE extraction_id = %s",
+            (extraction_id,),
+        )
+        if extraction_row:
+            sync_result = _sync_globalconnect_extraction_to_internet(extraction_row)
         
         logger.info(f"✅ Linked vendor {vendor['name']} (ID: {vendor_id}) to file {file_id}")
         
         return {
             "status": "success",
             "vendor_id": vendor_id,
-            "vendor_name": vendor['name']
+            "vendor_name": vendor['name'],
+            "internet_sync": sync_result,
         }
         
     except HTTPException:
@@ -1459,6 +2840,14 @@ async def link_vendor_to_extraction(file_id: int, data: dict):
             "UPDATE incoming_files SET detected_vendor_id = %s, status = 'processed' WHERE file_id = %s",
             (vendor_id, file_id)
         )
+
+        sync_result = None
+        extraction_row = execute_query_single(
+            "SELECT * FROM extractions WHERE extraction_id = %s",
+            (extraction_id,),
+        )
+        if extraction_row:
+            sync_result = _sync_globalconnect_extraction_to_internet(extraction_row)
         
         logger.info(f"✅ Linked vendor {vendor['name']} (ID: {vendor_id}) to extraction {extraction_id}")
         
@@ -1466,7 +2855,8 @@ async def link_vendor_to_extraction(file_id: int, data: dict):
             "status": "success",
             "vendor_id": vendor_id,
             "vendor_name": vendor['name'],
-            "extraction_id": extraction_id
+            "extraction_id": extraction_id,
+            "internet_sync": sync_result,
         }
         
     except HTTPException:
@@ -1523,6 +2913,10 @@ async def create_invoice_from_extraction(file_id: int):
                 llm_data = {}
         elif not llm_data:
             llm_data = {}
+
+        validation_warning = llm_data.get('_validation_warning') if isinstance(llm_data, dict) else None
+        vat_warning = llm_data.get('_vat_warning') if isinstance(llm_data, dict) else None
+        validation_details = llm_data.get('_validation_details') if isinstance(llm_data, dict) else None
         
         # Get invoice number and type from LLM data or generate one
         invoice_number = llm_data.get('invoice_number') if llm_data else None
@@ -1585,6 +2979,15 @@ async def create_invoice_from_extraction(file_id: int):
             currency=extraction_data.get("currency"),
             file_id=file_id,
         )
+        _append_amount_validation_case_note(
+            sag_id=sag_id,
+            invoice_id=invoice_id,
+            invoice_number=invoice_number,
+            validation_details=validation_details,
+            validation_warning=validation_warning,
+            vat_warning=vat_warning,
+            file_id=file_id,
+        )
         
         # Create invoice lines
         if lines:
@@ -1600,7 +3003,7 @@ async def create_invoice_from_extraction(file_id: int):
                 product_id = _ensure_product_for_supplier_line(
                     vendor_id=extraction_data.get('vendor_matched_id'),
                     vendor_name=extraction.get('vendor_name'),
-                    description=line.get('description'),
+                    description=_compose_supplier_line_description(line),
                     sku=sku,
                     unit_price=unit_price,
                     currency=extraction_data.get('currency'),
@@ -1615,7 +3018,7 @@ async def create_invoice_from_extraction(file_id: int):
                     (
                         invoice_id,
                         line.get('line_number'),
-                        line['description'],
+                        _compose_supplier_line_description(line),
                         quantity,
                         unit_price,
                         line_total,
@@ -1631,6 +3034,8 @@ async def create_invoice_from_extraction(file_id: int):
             "UPDATE incoming_files SET status = 'completed' WHERE file_id = %s",
             (file_id,)
         )
+
+        internet_sync_result = _sync_globalconnect_extraction_to_internet(extraction_data)
         
         logger.info(f"✅ Created supplier invoice {invoice_id} from extraction {extraction['extraction_id']}")
         
@@ -1641,7 +3046,13 @@ async def create_invoice_from_extraction(file_id: int):
             "invoice_number": invoice_number,
             "vendor_name": extraction['vendor_name'],
             "total_amount": extraction['total_amount'],
-            "currency": extraction['currency']
+            "currency": extraction['currency'],
+            "internet_sync": internet_sync_result,
+            "amount_validation": {
+                "warning": validation_warning,
+                "vat_warning": vat_warning,
+                "details": validation_details,
+            },
         }
         
     except HTTPException:
@@ -1651,13 +3062,31 @@ async def create_invoice_from_extraction(file_id: int):
         raise HTTPException(status_code=500, detail=str(e))
 
 
+@router.post("/supplier-invoices/files/{file_id}/sync-internet")
+async def sync_extraction_to_internet(file_id: int):
+    """Create or update internet connections/IP ranges from a GlobalConnect extraction."""
+    extraction = execute_query_single(
+        """
+        SELECT *
+        FROM extractions
+        WHERE file_id = %s
+        ORDER BY created_at DESC
+        LIMIT 1
+        """,
+        (file_id,),
+    )
+    if not extraction:
+        raise HTTPException(status_code=404, detail="Ingen extraction fundet for denne fil")
+
+    result = _sync_globalconnect_extraction_to_internet(extraction)
+    return {
+        "status": "success",
+        "file_id": file_id,
+        "internet_sync": result,
+    }
+
+
 # Keep existing endpoints below...
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"❌ Failed to delete file: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
 
 
 # ========== TEMPLATE MANAGEMENT (must be before {invoice_id} route) ==========
@@ -3197,13 +4626,17 @@ async def reprocess_uploaded_file(file_id: int):
                             """INSERT INTO extraction_lines
                                (extraction_id, line_number, description, quantity, unit_price, 
                                 line_total, vat_rate, vat_note, confidence,
-                                ip_address, contract_number, location_street, location_zip, location_city)
-                               VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+                                ip_address, contract_number, provider_reference, customer_reference, circuit_id,
+                                end_customer_name, period_start, period_end, service_address,
+                                location_street, location_zip, location_city)
+                               VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
                                RETURNING line_id""",
                             (extraction_id, idx, line.get('description'), 
                              quantity, unit_price,
                              line_total, None, None, 1.0,
                              line.get('ip_address'), line.get('contract_number'),
+                             line.get('provider_reference'), line.get('customer_reference'), line.get('circuit_id'),
+                             line.get('end_customer_name'), line.get('period_start'), line.get('period_end'), line.get('service_address'),
                              line.get('location_street'), line.get('location_zip'), line.get('location_city'))
                         )
                     logger.info(f"✅ Saved {len(extracted_fields['lines'])} line items")
@@ -3325,13 +4758,20 @@ async def reprocess_uploaded_file(file_id: int):
                     execute_insert(
                         """INSERT INTO extraction_lines
                            (extraction_id, line_number, description, quantity, unit_price, 
-                            line_total, vat_rate, confidence)
-                           VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+                            line_total, vat_rate, confidence,
+                            ip_address, contract_number, provider_reference, customer_reference, circuit_id,
+                            end_customer_name, period_start, period_end, service_address,
+                            location_street, location_zip, location_city)
+                           VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
                            RETURNING line_id""",
                         (extraction_id, idx, line.get('description'), 
                          line.get('quantity'), line.get('unit_price'),
                          line.get('line_total'), line.get('vat_rate'),
-                         confidence)
+                         confidence,
+                         line.get('ip_address'), line.get('contract_number'),
+                         line.get('provider_reference'), line.get('customer_reference'), line.get('circuit_id'),
+                         line.get('end_customer_name'), line.get('period_start'), line.get('period_end'), line.get('service_address'),
+                         line.get('location_street'), line.get('location_zip'), line.get('location_city'))
                     )
             
             # Update file status to ai_extracted
diff --git a/app/billing/frontend/supplier_invoices.html b/app/billing/frontend/supplier_invoices.html
index 52c078e..d7e3d8d 100644
--- a/app/billing/frontend/supplier_invoices.html
+++ b/app/billing/frontend/supplier_invoices.html
@@ -99,6 +99,51 @@
     .status-processing { background-color: #6c757d; color: #fff; }
     .status-failed { background-color: var(--danger); color: #fff; }
     .status-completed { background-color: var(--success); color: #fff; }
+
+    .sync-report-card {
+        border: 1px solid rgba(13, 110, 253, 0.14);
+        border-radius: 14px;
+        background: linear-gradient(180deg, rgba(13, 110, 253, 0.04), rgba(13, 110, 253, 0.015));
+    }
+
+    .sync-report-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+        gap: 0.75rem;
+    }
+
+    .sync-report-metric {
+        border: 1px solid rgba(13, 110, 253, 0.12);
+        border-radius: 12px;
+        padding: 0.75rem;
+        background: rgba(255,255,255,0.7);
+    }
+
+    .sync-report-metric .label {
+        display: block;
+        font-size: 0.72rem;
+        text-transform: uppercase;
+        letter-spacing: 0.04em;
+        color: var(--text-secondary);
+        margin-bottom: 0.2rem;
+    }
+
+    .sync-report-metric .value {
+        font-weight: 700;
+        font-size: 1.1rem;
+    }
+
+    .sync-line-list {
+        display: grid;
+        gap: 0.5rem;
+    }
+
+    .sync-line-item {
+        border: 1px solid rgba(0,0,0,0.08);
+        border-radius: 10px;
+        padding: 0.7rem 0.85rem;
+        background: #fff;
+    }
 </style>
 {% endblock %}
 
@@ -2036,6 +2081,114 @@ function getFileStatusBadge(status) {
     return badges[status] || `<span class="badge bg-secondary">${status}</span>`;
 }
 
+function renderSyncVerificationBadge(verification) {
+    if (!verification) return '';
+    if (verification.requires_manual_review) {
+        return '<span class="badge bg-danger">Kræver manuel kontrol</span>';
+    }
+    if (verification.fully_synced) {
+        return '<span class="badge bg-success">Alt er dækket</span>';
+    }
+    return '<span class="badge bg-secondary">Ingen internet-sync</span>';
+}
+
+function renderSyncReport(syncReport) {
+    if (!syncReport || syncReport.skipped) return '';
+
+    const verification = syncReport.verification || {};
+    const skippedItems = Array.isArray(syncReport.skipped_items) ? syncReport.skipped_items : [];
+    const lineAudit = Array.isArray(syncReport.line_audit) ? syncReport.line_audit : [];
+    const syncedLines = lineAudit.filter((item) => item.status === 'synced');
+    const ignoredLines = lineAudit.filter((item) => item.status === 'ignored');
+
+    const renderLine = (item, tone) => `
+        <div class="sync-line-item">
+            <div class="d-flex justify-content-between align-items-start gap-2">
+                <div>
+                    <div class="fw-semibold">Linje ${item.line_number || '-'} · ${escapeHtml(item.description || '-')}</div>
+                    <div class="small text-muted mt-1">
+                        ${item.provider_reference ? `Ref: ${escapeHtml(item.provider_reference)} · ` : ''}
+                        ${item.ip_address ? `IP/CIDR: ${escapeHtml(item.ip_address)} · ` : ''}
+                        ${item.service_address ? `Adresse: ${escapeHtml(item.service_address)}` : ''}
+                    </div>
+                    ${item.reason ? `<div class="small mt-1 text-${tone}">${escapeHtml(item.reason)}</div>` : ''}
+                </div>
+                <span class="badge bg-${tone}">${item.result ? escapeHtml(item.result) : escapeHtml(item.status)}</span>
+            </div>
+        </div>
+    `;
+
+    return `
+        <div class="sync-report-card p-3 mt-4">
+            <div class="d-flex justify-content-between align-items-start gap-3 mb-3">
+                <div>
+                    <h5 class="mb-1">Internet-importkontrol</h5>
+                    <div class="small text-muted">Alle relevante linjer er gennemgået enkeltvis. Alt der springes over vises her med årsag.</div>
+                </div>
+                <div>${renderSyncVerificationBadge(verification)}</div>
+            </div>
+
+            <div class="sync-report-grid mb-3">
+                <div class="sync-report-metric">
+                    <span class="label">Linjer i alt</span>
+                    <div class="value">${verification.total_lines || 0}</div>
+                </div>
+                <div class="sync-report-metric">
+                    <span class="label">Relevante linjer</span>
+                    <div class="value">${verification.actionable_lines || 0}</div>
+                </div>
+                <div class="sync-report-metric">
+                    <span class="label">Synkroniseret</span>
+                    <div class="value text-success">${verification.synced_actionable_lines || 0}</div>
+                </div>
+                <div class="sync-report-metric">
+                    <span class="label">Sprunget over</span>
+                    <div class="value text-danger">${verification.skipped_actionable_lines || 0}</div>
+                </div>
+                <div class="sync-report-metric">
+                    <span class="label">Forbindelser</span>
+                    <div class="value">${syncReport.connections_created || 0} ny · ${syncReport.connections_updated || 0} opdat.</div>
+                </div>
+                <div class="sync-report-metric">
+                    <span class="label">IP-ranges</span>
+                    <div class="value">${syncReport.ip_ranges_synced || 0}</div>
+                </div>
+            </div>
+
+            ${skippedItems.length ? `
+                <div class="alert alert-danger mb-3">
+                    <strong>${skippedItems.length} linjer blev sprunget over.</strong> De skal gennemgås manuelt før du kan være sikker på, at alt er oprettet.
+                </div>
+                <div class="sync-line-list mb-3">
+                    ${skippedItems.map((item) => renderLine(item, 'danger')).join('')}
+                </div>
+            ` : `
+                <div class="alert alert-success mb-3">
+                    Ingen relevante linjer blev sprunget over.
+                </div>
+            `}
+
+            ${syncedLines.length ? `
+                <details class="mb-3">
+                    <summary class="fw-semibold">Vis synkroniserede linjer (${syncedLines.length})</summary>
+                    <div class="sync-line-list mt-2">
+                        ${syncedLines.map((item) => renderLine(item, 'success')).join('')}
+                    </div>
+                </details>
+            ` : ''}
+
+            ${ignoredLines.length ? `
+                <details>
+                    <summary class="fw-semibold">Vis linjer uden internet-handling (${ignoredLines.length})</summary>
+                    <div class="sync-line-list mt-2">
+                        ${ignoredLines.map((item) => renderLine(item, 'secondary')).join('')}
+                    </div>
+                </details>
+            ` : ''}
+        </div>
+    `;
+}
+
 // NEW: Batch analyze all files
 async function batchAnalyzeAllFiles() {
     if (!confirm('Kør automatisk analyse på alle ubehandlede filer?\n\nDette kan tage flere minutter afhængigt af antal filer.\nSiden opdateres automatisk undervejs.')) {
@@ -2757,6 +2910,7 @@ async function reviewExtractedData(fileId) {
         
         const ext = data.extraction;
         const lines = data.extraction_lines || [];
+        const syncPreview = data.internet_sync_preview || null;
         
         // Parse JSON if llm_response_json exists
         let aiData = null;
@@ -2840,6 +2994,8 @@ async function reviewExtractedData(fileId) {
                     <pre class="mb-0 text-body" style="font-size: 0.85rem; white-space: pre-wrap; word-wrap: break-word; font-family: monospace; line-height: 1.3;">${escapeHtml(data.pdf_text_preview)}</pre>
                 </div>
             ` : '<div class="alert alert-warning mt-3"><i class="bi bi-exclamation-triangle me-2"></i>PDF tekst ikke tilgængelig - prøv at genbehandle filen</div>'}
+
+            ${renderSyncReport(syncPreview)}
         `;
         
         document.getElementById('reviewModalContent').innerHTML = modalContent;
@@ -3188,7 +3344,11 @@ async function createInvoiceFromExtraction() {
         
         if (response.ok) {
             const result = await response.json();
-            alert(`✅ Faktura oprettet!\n\nFakturanummer: ${result.invoice_number}\nLeverandør: ${result.vendor_name}\nBeløb: ${result.total_amount} ${result.currency}`);
+            const syncReport = result.internet_sync || null;
+            const syncWarning = syncReport?.verification?.requires_manual_review
+                ? `\n\nADVARSEL: ${syncReport.verification.skipped_actionable_lines} internet-linjer blev sprunget over. Åbn review igen og kontroller dem.`
+                : '';
+            alert(`✅ Faktura oprettet!\n\nFakturanummer: ${result.invoice_number}\nLeverandør: ${result.vendor_name}\nBeløb: ${result.total_amount} ${result.currency}${syncWarning}`);
             
             // Close modal and refresh
             const modalInstance = bootstrap.Modal.getInstance(modal);
diff --git a/app/customers/frontend/customer_detail.html b/app/customers/frontend/customer_detail.html
index a740816..2517549 100644
--- a/app/customers/frontend/customer_detail.html
+++ b/app/customers/frontend/customer_detail.html
@@ -80,6 +80,112 @@
         font-weight: 700;
         color: var(--text-primary);
     }
+
+    .internet-stat-card {
+        background: linear-gradient(180deg, rgba(15, 76, 117, 0.04), rgba(15, 76, 117, 0.01));
+        border: 1px solid rgba(15, 76, 117, 0.14);
+        border-radius: 14px;
+        padding: 1rem;
+        height: 100%;
+    }
+
+    .internet-stat-label {
+        color: var(--text-secondary);
+        font-size: 0.78rem;
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+        margin-bottom: 0.35rem;
+    }
+
+    .internet-stat-value {
+        color: var(--text-primary);
+        font-size: 1.4rem;
+        font-weight: 700;
+    }
+
+    .internet-shell {
+        background: linear-gradient(180deg, rgba(15, 76, 117, 0.05), rgba(255, 255, 255, 0));
+        border: 1px solid rgba(15, 76, 117, 0.12);
+        border-radius: 18px;
+        padding: 1.25rem;
+    }
+
+    .internet-connection-card {
+        border: 1px solid rgba(15, 76, 117, 0.12);
+        border-radius: 16px;
+        background: var(--bg-card);
+        padding: 1rem;
+        box-shadow: 0 10px 24px rgba(15, 76, 117, 0.06);
+    }
+
+    .internet-connection-card + .internet-connection-card {
+        margin-top: 0.9rem;
+    }
+
+    .internet-meta-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+        gap: 0.75rem;
+    }
+
+    .internet-meta-item {
+        background: rgba(15, 76, 117, 0.04);
+        border-radius: 12px;
+        padding: 0.75rem;
+    }
+
+    .internet-meta-item .label {
+        display: block;
+        color: var(--text-secondary);
+        font-size: 0.74rem;
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+        margin-bottom: 0.25rem;
+    }
+
+    .internet-meta-item .value {
+        color: var(--text-primary);
+        font-weight: 600;
+    }
+
+    .internet-status-pill {
+        display: inline-flex;
+        align-items: center;
+        gap: 0.35rem;
+        border-radius: 999px;
+        padding: 0.35rem 0.7rem;
+        font-size: 0.75rem;
+        font-weight: 700;
+        letter-spacing: 0.04em;
+        text-transform: uppercase;
+    }
+
+    .internet-status-active {
+        background: rgba(25, 135, 84, 0.12);
+        color: #146c43;
+    }
+
+    .internet-status-inactive {
+        background: rgba(108, 117, 125, 0.14);
+        color: #495057;
+    }
+
+    .internet-status-pending, .internet-status-planned {
+        background: rgba(255, 193, 7, 0.18);
+        color: #997404;
+    }
+
+    .internet-status-terminated, .internet-status-cancelled {
+        background: rgba(220, 53, 69, 0.12);
+        color: #b02a37;
+    }
+
+    .internet-create-panel {
+        border: 1px dashed rgba(15, 76, 117, 0.22);
+        border-radius: 16px;
+        background: rgba(15, 76, 117, 0.03);
+        padding: 1rem;
+    }
     
     .info-row {
         display: flex;
@@ -566,6 +672,11 @@
                         <i class="bi bi-geo-alt"></i>Lokationer
                     </a>
                 </li>
+                <li class="nav-item">
+                    <a class="nav-link" data-bs-toggle="tab" href="#internet-connections">
+                        <i class="bi bi-hdd-network"></i>Internet
+                    </a>
+                </li>
                 <li class="nav-item">
                     <a class="nav-link" data-bs-toggle="tab" href="#hardware">
                         <i class="bi bi-hdd"></i>Hardware
@@ -1191,6 +1302,112 @@
             </div>
         </div>
 
+        <div class="tab-pane fade" id="internet-connections">
+            <div class="internet-shell">
+                <div class="d-flex flex-column flex-lg-row justify-content-between align-items-lg-center gap-3 mb-4">
+                    <div>
+                        <h5 class="fw-bold mb-1">
+                            <i class="bi bi-hdd-network me-2"></i>Internetforbindelser
+                        </h5>
+                        <div class="text-muted">Fiber, WAN, kredsløb, IP-ranges og økonomi samlet på kunden.</div>
+                    </div>
+                    <div class="d-flex gap-2 flex-wrap">
+                        <a class="btn btn-sm btn-outline-secondary" href="/economy/internet-connections">
+                            <i class="bi bi-box-arrow-up-right me-1"></i>Åbn modul
+                        </a>
+                        <button class="btn btn-sm btn-primary" type="button" onclick="toggleCustomerInternetCreate()">
+                            <i class="bi bi-plus-lg me-1"></i>Ny forbindelse
+                        </button>
+                    </div>
+                </div>
+
+                <div class="row g-3 mb-4">
+                    <div class="col-6 col-xl-3">
+                        <div class="internet-stat-card">
+                            <div class="internet-stat-label">Forbindelser</div>
+                            <div class="internet-stat-value" id="customerInternetCount">0</div>
+                        </div>
+                    </div>
+                    <div class="col-6 col-xl-3">
+                        <div class="internet-stat-card">
+                            <div class="internet-stat-label">Månedlig kost</div>
+                            <div class="internet-stat-value" id="customerInternetCost">0 kr.</div>
+                        </div>
+                    </div>
+                    <div class="col-6 col-xl-3">
+                        <div class="internet-stat-card">
+                            <div class="internet-stat-label">Månedligt salg</div>
+                            <div class="internet-stat-value" id="customerInternetSales">0 kr.</div>
+                        </div>
+                    </div>
+                    <div class="col-6 col-xl-3">
+                        <div class="internet-stat-card">
+                            <div class="internet-stat-label">Aktive IP'er</div>
+                            <div class="internet-stat-value" id="customerInternetIps">0</div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="internet-create-panel mb-4 d-none" id="customerInternetCreatePanel">
+                    <div class="d-flex justify-content-between align-items-center mb-3">
+                        <div>
+                            <div class="fw-semibold">Opret forbindelse på kunden</div>
+                            <div class="small text-muted">Knytter automatisk forbindelsen til denne kunde.</div>
+                        </div>
+                        <button class="btn btn-sm btn-outline-secondary" type="button" onclick="toggleCustomerInternetCreate(false)">Luk</button>
+                    </div>
+                    <div class="row g-2">
+                        <div class="col-md-4">
+                            <input type="text" class="form-control" id="customerInternetName" placeholder="Navn på forbindelse">
+                        </div>
+                        <div class="col-md-3">
+                            <input type="text" class="form-control" id="customerInternetProvider" placeholder="Leverandør">
+                        </div>
+                        <div class="col-md-2">
+                            <input type="text" class="form-control" id="customerInternetCircuit" placeholder="Kredsløb">
+                        </div>
+                        <div class="col-md-3">
+                            <input type="text" class="form-control" id="customerInternetTechnology" placeholder="Teknologi">
+                        </div>
+                        <div class="col-md-4">
+                            <input type="text" class="form-control" id="customerInternetAddress" placeholder="Installationsadresse">
+                        </div>
+                        <div class="col-md-2">
+                            <input type="number" class="form-control" id="customerInternetDownload" placeholder="Download">
+                        </div>
+                        <div class="col-md-2">
+                            <input type="number" class="form-control" id="customerInternetUpload" placeholder="Upload">
+                        </div>
+                        <div class="col-md-2">
+                            <input type="number" class="form-control" id="customerInternetCostInput" placeholder="Kost">
+                        </div>
+                        <div class="col-md-2">
+                            <input type="number" class="form-control" id="customerInternetSalesInput" placeholder="Salg">
+                        </div>
+                        <div class="col-md-12">
+                            <textarea class="form-control" id="customerInternetNotes" rows="2" placeholder="Noter, SLA, overvågning, aftaler..."></textarea>
+                        </div>
+                    </div>
+                    <div class="mt-3 d-flex gap-2">
+                        <button class="btn btn-primary" type="button" onclick="createCustomerInternetConnection()">Gem forbindelse</button>
+                        <div class="small text-muted align-self-center" id="customerInternetCreateFeedback"></div>
+                    </div>
+                </div>
+
+                <div id="customerInternetLoading" class="text-center py-5">
+                    <div class="spinner-border spinner-border-sm text-primary"></div>
+                    <div class="text-muted mt-2">Henter internetforbindelser...</div>
+                </div>
+
+                <div id="customerInternetEmpty" class="text-center py-5 d-none">
+                    <div class="fw-semibold mb-1">Ingen internetforbindelser på kunden endnu</div>
+                    <div class="text-muted">Opret den første forbindelse direkte her eller i internetmodulet.</div>
+                </div>
+
+                <div id="customerInternetList" class="d-none"></div>
+            </div>
+        </div>
+
         <!-- Hardware Tab -->
         <div class="tab-pane fade" id="hardware">
             <div class="d-flex justify-content-between align-items-center mb-4">
@@ -1878,6 +2095,13 @@ document.addEventListener('DOMContentLoaded', () => {
         }, { once: false });
     }
 
+    const internetConnectionsTab = document.querySelector('a[href="#internet-connections"]');
+    if (internetConnectionsTab) {
+        internetConnectionsTab.addEventListener('shown.bs.tab', () => {
+            loadCustomerInternetConnections();
+        }, { once: false });
+    }
+
     // Load hardware when tab is shown
     const hardwareTab = document.querySelector('a[href="#hardware"]');
     if (hardwareTab) {
@@ -5642,6 +5866,204 @@ function formatShortDate(value) {
     return date.toLocaleDateString('da-DK');
 }
 
+async function loadCustomerInternetConnections() {
+    const loading = document.getElementById('customerInternetLoading');
+    const empty = document.getElementById('customerInternetEmpty');
+    const list = document.getElementById('customerInternetList');
+
+    if (!loading || !empty || !list) return;
+
+    loading.classList.remove('d-none');
+    empty.classList.add('d-none');
+    list.classList.add('d-none');
+
+    try {
+        const response = await fetch(`/api/v1/internet-connections?customer_id=${customerId}`);
+        const payload = await response.json();
+        if (!response.ok) {
+            throw new Error(payload.detail || 'Kunne ikke hente internetforbindelser');
+        }
+
+        const connections = Array.isArray(payload) ? payload : [];
+        window.__customerInternetConnections = connections;
+        renderCustomerInternetConnections(connections);
+    } catch (error) {
+        loading.innerHTML = `<div class="alert alert-danger mb-0"><i class="bi bi-exclamation-circle me-2"></i>${escapeHtml(error.message || 'Ukendt fejl')}</div>`;
+    }
+}
+
+function renderCustomerInternetConnections(connections) {
+    const loading = document.getElementById('customerInternetLoading');
+    const empty = document.getElementById('customerInternetEmpty');
+    const list = document.getElementById('customerInternetList');
+
+    const items = Array.isArray(connections) ? connections : [];
+    const totalCost = items.reduce((sum, item) => sum + Number(item.monthly_cost || 0), 0);
+    const totalSales = items.reduce((sum, item) => sum + Number(item.sales_price || 0), 0);
+    const totalInUseIps = items.reduce((sum, item) => sum + Number(item.in_use_ip_addresses || 0), 0);
+
+    document.getElementById('customerInternetCount').textContent = String(items.length);
+    document.getElementById('customerInternetCost').textContent = formatDKK(totalCost);
+    document.getElementById('customerInternetSales').textContent = formatDKK(totalSales);
+    document.getElementById('customerInternetIps').textContent = String(totalInUseIps);
+
+    loading.classList.add('d-none');
+
+    if (!items.length) {
+        empty.classList.remove('d-none');
+        list.classList.add('d-none');
+        list.innerHTML = '';
+        return;
+    }
+
+    empty.classList.add('d-none');
+    list.classList.remove('d-none');
+    list.innerHTML = items.map((item) => {
+        const status = String(item.status || 'active').toLowerCase();
+        const statusClass = {
+            active: 'internet-status-active',
+            inactive: 'internet-status-inactive',
+            planned: 'internet-status-planned',
+            pending: 'internet-status-pending',
+            terminated: 'internet-status-terminated',
+            cancelled: 'internet-status-cancelled',
+        }[status] || 'internet-status-inactive';
+
+        const parentLabel = item.parent_name
+            ? `<div class="small text-muted"><i class="bi bi-diagram-2 me-1"></i>Ligger under ${escapeHtml(item.parent_name)}</div>`
+            : '';
+
+        const monitoring = item.monitoring_url
+            ? `<a href="${escapeHtml(item.monitoring_url)}" target="_blank" class="btn btn-sm btn-outline-secondary"><i class="bi bi-activity me-1"></i>Overvågning</a>`
+            : '';
+
+        return `
+            <div class="internet-connection-card">
+                <div class="d-flex flex-column flex-lg-row justify-content-between align-items-lg-start gap-3 mb-3">
+                    <div>
+                        <div class="d-flex align-items-center gap-2 flex-wrap">
+                            <h6 class="mb-0">${escapeHtml(item.name || '-')}</h6>
+                            <span class="internet-status-pill ${statusClass}">${escapeHtml(item.status || '-')}</span>
+                        </div>
+                        <div class="text-muted mt-1">${escapeHtml(item.provider || 'Ingen leverandør')} · ${escapeHtml(item.connection_type || item.technology || 'Forbindelse')}</div>
+                        ${parentLabel}
+                    </div>
+                    <div class="d-flex gap-2 flex-wrap">
+                        ${monitoring}
+                        <a href="/economy/internet-connections/${item.id}" class="btn btn-sm btn-primary">
+                            <i class="bi bi-eye me-1"></i>Åbn
+                        </a>
+                    </div>
+                </div>
+                <div class="internet-meta-grid">
+                    <div class="internet-meta-item">
+                        <span class="label">Adresse</span>
+                        <span class="value">${escapeHtml(item.address || '-')}</span>
+                    </div>
+                    <div class="internet-meta-item">
+                        <span class="label">Kredsløb</span>
+                        <span class="value">${escapeHtml(item.circuit_number || '-')}</span>
+                    </div>
+                    <div class="internet-meta-item">
+                        <span class="label">Hastighed</span>
+                        <span class="value">${formatConnectionSpeed(item)}</span>
+                    </div>
+                    <div class="internet-meta-item">
+                        <span class="label">Kost / salg</span>
+                        <span class="value">${formatDKK(Number(item.monthly_cost || 0))} / ${formatDKK(Number(item.sales_price || 0))}</span>
+                    </div>
+                    <div class="internet-meta-item">
+                        <span class="label">DB</span>
+                        <span class="value">${formatDKK(Number(item.margin_amount || 0))}</span>
+                    </div>
+                    <div class="internet-meta-item">
+                        <span class="label">IP i brug</span>
+                        <span class="value">${Number(item.in_use_ip_addresses || 0)} af ${Number(item.total_ip_addresses || 0)}</span>
+                    </div>
+                </div>
+            </div>
+        `;
+    }).join('');
+}
+
+function formatConnectionSpeed(item) {
+    const download = Number(item.download_mbps || 0);
+    const upload = Number(item.upload_mbps || 0);
+    const speed = Number(item.speed_mbps || 0);
+    if (download || upload) {
+        return `${download || 0}/${upload || 0} Mbps`;
+    }
+    if (speed) {
+        return `${speed} Mbps`;
+    }
+    return '-';
+}
+
+function toggleCustomerInternetCreate(forceState) {
+    const panel = document.getElementById('customerInternetCreatePanel');
+    if (!panel) return;
+    const shouldShow = typeof forceState === 'boolean' ? forceState : panel.classList.contains('d-none');
+    panel.classList.toggle('d-none', !shouldShow);
+}
+
+async function createCustomerInternetConnection() {
+    const feedback = document.getElementById('customerInternetCreateFeedback');
+    const payload = {
+        customer_id: customerId,
+        name: document.getElementById('customerInternetName').value.trim(),
+        provider: document.getElementById('customerInternetProvider').value.trim() || null,
+        circuit_number: document.getElementById('customerInternetCircuit').value.trim() || null,
+        technology: document.getElementById('customerInternetTechnology').value.trim() || null,
+        address: document.getElementById('customerInternetAddress').value.trim() || null,
+        download_mbps: Number(document.getElementById('customerInternetDownload').value || 0) || null,
+        upload_mbps: Number(document.getElementById('customerInternetUpload').value || 0) || null,
+        monthly_cost: Number(document.getElementById('customerInternetCostInput').value || 0),
+        sales_price: Number(document.getElementById('customerInternetSalesInput').value || 0),
+        notes: document.getElementById('customerInternetNotes').value.trim() || null,
+        status: 'active',
+        connection_type: 'fiber',
+    };
+
+    if (!payload.name) {
+        feedback.textContent = 'Navn er påkrævet.';
+        return;
+    }
+
+    feedback.textContent = 'Gemmer...';
+    try {
+        const response = await fetch('/api/v1/internet-connections', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        const result = await response.json();
+        if (!response.ok) {
+            throw new Error(result.detail || 'Kunne ikke oprette forbindelse');
+        }
+
+        [
+            'customerInternetName',
+            'customerInternetProvider',
+            'customerInternetCircuit',
+            'customerInternetTechnology',
+            'customerInternetAddress',
+            'customerInternetDownload',
+            'customerInternetUpload',
+            'customerInternetCostInput',
+            'customerInternetSalesInput',
+            'customerInternetNotes',
+        ].forEach((id) => {
+            const field = document.getElementById(id);
+            if (field) field.value = '';
+        });
+        feedback.textContent = 'Forbindelse oprettet.';
+        await loadCustomerInternetConnections();
+        toggleCustomerInternetCreate(false);
+    } catch (error) {
+        feedback.textContent = error.message || 'Kunne ikke oprette forbindelse';
+    }
+}
+
 function editInternalComment() {
     const commentText = document.getElementById('commentText').textContent;
     const commentInput = document.getElementById('internalCommentInput');
diff --git a/app/modules/internet_connections/__init__.py b/app/modules/internet_connections/__init__.py
new file mode 100644
index 0000000..fd54587
--- /dev/null
+++ b/app/modules/internet_connections/__init__.py
@@ -0,0 +1 @@
+"""Internet connections module package."""
diff --git a/app/modules/internet_connections/backend/provisioning_utils.py b/app/modules/internet_connections/backend/provisioning_utils.py
new file mode 100644
index 0000000..3c43e8d
--- /dev/null
+++ b/app/modules/internet_connections/backend/provisioning_utils.py
@@ -0,0 +1,143 @@
+import json
+import re
+from typing import Any, Dict, List, Optional
+
+
+NETWORK_KINDS = {"internet_access", "ip_allocation"}
+
+
+def parse_product_attributes(raw: Any) -> Dict[str, Any]:
+    if raw is None:
+        return {}
+    if isinstance(raw, dict):
+        return raw
+    if isinstance(raw, str):
+        text = raw.strip()
+        if not text:
+            return {}
+        try:
+            parsed = json.loads(text)
+        except json.JSONDecodeError:
+            return {}
+        return parsed if isinstance(parsed, dict) else {}
+    return {}
+
+
+def _parse_speed_from_text(text: str) -> Dict[str, Optional[int]]:
+    match = re.search(r"(\d+)\s*/\s*(\d+)\s*(?:mbit|mbps|gbit|gbps)?", text, re.IGNORECASE)
+    if not match:
+        return {"speed_mbps": None, "download_mbps": None, "upload_mbps": None}
+
+    download = int(match.group(1))
+    upload = int(match.group(2))
+    if re.search(r"(gbit|gbps)", text, re.IGNORECASE):
+        download *= 1000
+        upload *= 1000
+
+    return {
+        "speed_mbps": max(download, upload),
+        "download_mbps": download,
+        "upload_mbps": upload,
+    }
+
+
+def _parse_prefix_from_text(text: str) -> Optional[int]:
+    match = re.search(r"/(\d{1,2})", text)
+    if not match:
+        return None
+    try:
+        prefix = int(match.group(1))
+    except ValueError:
+        return None
+    return prefix if 0 <= prefix <= 32 else None
+
+
+def build_network_product_profile(product: Dict[str, Any], fallback_text: Optional[str] = None) -> Dict[str, Any]:
+    attributes = parse_product_attributes(product.get("attributes_json"))
+    network = attributes.get("network") if isinstance(attributes.get("network"), dict) else {}
+
+    text = " ".join(
+        part for part in [
+            str(product.get("name") or "").strip(),
+            str(product.get("product_name") or "").strip(),
+            str(product.get("description") or "").strip(),
+            str(fallback_text or "").strip(),
+        ]
+        if part
+    )
+    lowered = text.lower()
+
+    kind = (
+        network.get("kind")
+        or attributes.get("network_kind")
+        or product.get("network_kind")
+        or product.get("type")
+    )
+    if kind not in NETWORK_KINDS:
+        if "/3" in lowered and "ip" in lowered:
+            kind = "ip_allocation"
+        elif re.search(r"/\d{1,2}", lowered) and "ip" in lowered:
+            kind = "ip_allocation"
+        elif "bmcnet" in lowered or "internet" in lowered or "fiber" in lowered:
+            kind = "internet_access"
+        else:
+            kind = None
+
+    speeds = _parse_speed_from_text(text)
+    speed_mbps = network.get("speed_mbps") or attributes.get("speed_mbps") or speeds["speed_mbps"]
+    download_mbps = network.get("download_mbps") or attributes.get("download_mbps") or speeds["download_mbps"]
+    upload_mbps = network.get("upload_mbps") or attributes.get("upload_mbps") or speeds["upload_mbps"]
+    ip_prefix_length = network.get("ip_prefix_length") or attributes.get("ip_prefix_length") or _parse_prefix_from_text(text)
+    connection_type = network.get("connection_type") or attributes.get("connection_type")
+
+    return {
+        "kind": kind,
+        "is_network_product": kind in NETWORK_KINDS,
+        "requires_provisioning": kind in NETWORK_KINDS,
+        "speed_mbps": int(speed_mbps) if speed_mbps is not None else None,
+        "download_mbps": int(download_mbps) if download_mbps is not None else None,
+        "upload_mbps": int(upload_mbps) if upload_mbps is not None else None,
+        "ip_prefix_length": int(ip_prefix_length) if ip_prefix_length is not None else None,
+        "connection_type": connection_type,
+        "attributes": attributes,
+    }
+
+
+def summarize_subscription_network_requirements(line_items: List[Dict[str, Any]]) -> Dict[str, Any]:
+    internet_items: List[Dict[str, Any]] = []
+    ip_items: List[Dict[str, Any]] = []
+
+    for item in line_items or []:
+        profile = build_network_product_profile(item, fallback_text=item.get("description"))
+        if not profile["requires_provisioning"]:
+            continue
+
+        entry = {
+            "subscription_item_id": item.get("id"),
+            "line_no": item.get("line_no"),
+            "product_id": item.get("product_id"),
+            "product_name": item.get("product_name") or item.get("description"),
+            "description": item.get("description"),
+            "quantity": item.get("quantity"),
+            "unit_price": item.get("unit_price"),
+            "line_total": item.get("line_total"),
+            "network_kind": profile["kind"],
+            "speed_mbps": profile["speed_mbps"],
+            "download_mbps": profile["download_mbps"],
+            "upload_mbps": profile["upload_mbps"],
+            "ip_prefix_length": profile["ip_prefix_length"],
+            "connection_type": profile["connection_type"],
+        }
+        if profile["kind"] == "internet_access":
+            internet_items.append(entry)
+        elif profile["kind"] == "ip_allocation":
+            ip_items.append(entry)
+
+    primary_internet_item = internet_items[0] if internet_items else None
+    return {
+        "requires_provisioning": bool(internet_items or ip_items),
+        "internet_items": internet_items,
+        "ip_items": ip_items,
+        "primary_internet_item": primary_internet_item,
+        "required_ip_prefixes": [item["ip_prefix_length"] for item in ip_items if item.get("ip_prefix_length") is not None],
+    }
diff --git a/app/modules/internet_connections/backend/router.py b/app/modules/internet_connections/backend/router.py
new file mode 100644
index 0000000..1581408
--- /dev/null
+++ b/app/modules/internet_connections/backend/router.py
@@ -0,0 +1,3122 @@
+import ipaddress
+import logging
+import re
+from datetime import date
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, File, Form, HTTPException, Query, UploadFile
+from pydantic import BaseModel
+
+from app.core.config import settings
+from app.core.database import (
+    execute_insert,
+    execute_query,
+    execute_query_single,
+    get_db_connection,
+    release_db_connection,
+    table_has_column,
+)
+from psycopg2.extras import Json, RealDictCursor
+from app.modules.internet_connections.backend.provisioning_utils import (
+    build_network_product_profile,
+    summarize_subscription_network_requirements,
+)
+from app.services.ollama_service import ollama_service
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+ALLOWED_ALLOCATION_MODELS = {"dedicated", "shared"}
+ALLOWED_VALUE_TYPES = {"subscription", "bmc_networks", "delefiber", "other"}
+INTERNET_CUSTOMER_DOC_EXTENSIONS = {".txt", ".csv", ".log", ".md"}
+INTERNET_RESEARCH_KEYWORDS = (
+    "internet",
+    "bredbaand",
+    "bredbånd",
+    "broadband",
+    "fiber",
+    "wan",
+    "mpls",
+    "vpn",
+    "ip",
+    "ipv4",
+    "ipv6",
+    "ip-adresse",
+    "globalconnect",
+    "global connect",
+    "sentia",
+    "dsl",
+)
+REFERENCE_PATTERNS = [
+    r"\bNKA[- ]?\d{4,}\b",
+    r"\bDSL[- ]?[A-Z0-9]+\b",
+    r"\bEB\d{4,}\b",
+    r"\bHB\d{4,}\b",
+    r"\bMPLS\b",
+]
+SOCKET_PATTERNS = [
+    r"\bstik(?:\s*nr|\s*nummer)?[:#\s-]*([A-Za-z0-9./_-]{1,40})\b",
+    r"\budtag(?:\s*nr|\s*nummer)?[:#\s-]*([A-Za-z0-9./_-]{1,40})\b",
+    r"\bport[:#\s-]*([A-Za-z0-9./_-]{1,40})\b",
+]
+GENERIC_SEGMENT_TITLE_PATTERNS = (
+    "ip informationer",
+    "ip information",
+    "host is up",
+    "not in use",
+    "untagged native management",
+)
+
+
+def _internet_customer_doc_dir() -> Path:
+    base = Path(settings.UPLOAD_DIR).resolve()
+    target = base / "internet_customer_docs"
+    target.mkdir(parents=True, exist_ok=True)
+    return target
+
+
+def _sanitize_upload_name(filename: str) -> str:
+    cleaned = re.sub(r"[^A-Za-z0-9._-]+", "_", str(filename or "").strip())
+    cleaned = cleaned.strip("._")
+    return cleaned or "upload.txt"
+
+
+def _normalize_text_for_match(value: Optional[str]) -> str:
+    text = str(value or "").strip().lower()
+    return (
+        text.replace("æ", "ae")
+        .replace("ø", "oe")
+        .replace("å", "aa")
+        .replace("\n", " ")
+        .replace("\r", " ")
+    )
+
+
+def _tokenize_search_text(*parts: Optional[str]) -> List[str]:
+    combined = " ".join(str(part or "") for part in parts).strip().lower()
+    normalized = _normalize_text_for_match(combined)
+    tokens = []
+    for token in re.split(r"[^a-z0-9./+-]+", normalized):
+        token = token.strip()
+        if len(token) >= 2 and token not in tokens:
+            tokens.append(token)
+    return tokens
+
+
+def _build_research_terms(customer_name: str, query: Optional[str]) -> Dict[str, List[str]]:
+    customer_terms = [token for token in _tokenize_search_text(customer_name) if len(token) >= 3]
+    query_terms = [token for token in _tokenize_search_text(query) if len(token) >= 2]
+    internet_terms = list(INTERNET_RESEARCH_KEYWORDS)
+    combined = []
+    for term in customer_terms + query_terms + internet_terms:
+        if term not in combined:
+            combined.append(term)
+    return {
+        "customer_terms": customer_terms,
+        "query_terms": query_terms,
+        "internet_terms": internet_terms,
+        "all_terms": combined,
+    }
+
+
+def _count_term_hits(text: str, terms: List[str]) -> int:
+    normalized = _normalize_text_for_match(text)
+    return sum(1 for term in terms if term and term in normalized)
+
+
+def _extract_text_snippets(text: str, terms: List[str], limit: int = 4) -> List[str]:
+    normalized_terms = [term for term in (_normalize_text_for_match(term) for term in terms) if term]
+    if not text.strip():
+        return []
+
+    snippets: List[str] = []
+    seen = set()
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    for idx, line in enumerate(lines):
+        line_normalized = _normalize_text_for_match(line)
+        score = sum(1 for term in normalized_terms if term in line_normalized)
+        if score <= 0:
+            continue
+        start = max(idx - 1, 0)
+        end = min(idx + 2, len(lines))
+        snippet = " | ".join(lines[start:end])
+        snippet = re.sub(r"\s+", " ", snippet).strip()
+        if snippet and snippet not in seen:
+            seen.add(snippet)
+            snippets.append((score, snippet))
+
+    if not snippets and lines:
+        fallback = " | ".join(lines[: min(3, len(lines))])
+        return [re.sub(r"\s+", " ", fallback).strip()]
+
+    snippets.sort(key=lambda item: (-item[0], len(item[1])))
+    return [snippet for _, snippet in snippets[:limit]]
+
+
+def _is_generic_segment_title(title: Optional[str]) -> bool:
+    normalized_title = _normalize_text_for_match(title)
+    if not normalized_title:
+        return False
+    return any(pattern in normalized_title for pattern in GENERIC_SEGMENT_TITLE_PATTERNS)
+
+
+def _split_text_into_blocks(text: str) -> List[str]:
+    if not str(text or "").strip():
+        return []
+    raw_blocks = re.split(r"\n\s*\n+", str(text))
+    blocks: List[str] = []
+    for block in raw_blocks:
+        cleaned = re.sub(r"\s+\n", "\n", block).strip()
+        cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
+        if not cleaned:
+            continue
+        if len(cleaned) > 1800:
+            lines = [line.strip() for line in cleaned.splitlines() if line.strip()]
+            chunk: List[str] = []
+            chunk_len = 0
+            for line in lines:
+                if chunk and chunk_len + len(line) > 1200:
+                    blocks.append("\n".join(chunk))
+                    chunk = [line]
+                    chunk_len = len(line)
+                else:
+                    chunk.append(line)
+                    chunk_len += len(line)
+            if chunk:
+                blocks.append("\n".join(chunk))
+        else:
+            blocks.append(cleaned)
+    return blocks
+
+
+def _extract_segment_entities(block: str) -> Dict[str, List[str]]:
+    cidr_blocks = []
+    ip_addresses = []
+    references = []
+    socket_numbers = []
+
+    for raw in re.findall(r"\b(?:\d{1,3}\.){3}\d{1,3}/\d{1,2}\b", block):
+        normalized = raw.strip()
+        if normalized not in cidr_blocks:
+            cidr_blocks.append(normalized)
+
+    for raw in re.findall(r"\b(?:\d{1,3}\.){3}\d{1,3}\b", block):
+        normalized = raw.strip()
+        if any(normalized == cidr.split("/")[0] for cidr in cidr_blocks):
+            continue
+        try:
+            normalized_ip = _normalize_ip_address(normalized)
+        except HTTPException:
+            continue
+        if normalized_ip not in ip_addresses:
+            ip_addresses.append(normalized_ip)
+
+    for pattern in REFERENCE_PATTERNS:
+        for match in re.findall(pattern, block, flags=re.IGNORECASE):
+            normalized = re.sub(r"\s+", "", str(match).strip()).upper()
+            if normalized not in references:
+                references.append(normalized)
+
+    for pattern in SOCKET_PATTERNS:
+        for match in re.findall(pattern, block, flags=re.IGNORECASE):
+            normalized = str(match).strip()
+            if normalized and normalized not in socket_numbers:
+                socket_numbers.append(normalized)
+
+    return {
+        "ip_addresses": ip_addresses,
+        "cidr_blocks": cidr_blocks,
+        "references": references,
+        "socket_numbers": socket_numbers,
+    }
+
+
+def _segment_title(block: str, block_index: int) -> str:
+    first_line = next((line.strip() for line in block.splitlines() if line.strip()), "")
+    return (first_line[:120] if first_line else f"Blok {block_index + 1}") or f"Blok {block_index + 1}"
+
+
+def _index_customer_document_segments(document_id: int, extracted_text: str) -> int:
+    execute_query(
+        """
+        DELETE FROM internet_connections_customer_document_segments
+        WHERE document_id = %s
+        """,
+        (document_id,),
+    )
+    created = 0
+    for idx, block in enumerate(_split_text_into_blocks(extracted_text)):
+        entities = _extract_segment_entities(block)
+        execute_query(
+            """
+            INSERT INTO internet_connections_customer_document_segments (
+                document_id,
+                block_index,
+                block_title,
+                content,
+                ip_addresses,
+                cidr_blocks,
+                references_json,
+                socket_numbers
+            )
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+            """,
+            (
+                document_id,
+                idx,
+                _segment_title(block, idx),
+                block,
+                Json(entities["ip_addresses"]),
+                Json(entities["cidr_blocks"]),
+                Json(entities["references"]),
+                Json(entities["socket_numbers"]),
+            ),
+        )
+        created += 1
+    return created
+
+
+def _get_document_segment_count(document_id: int) -> int:
+    row = execute_query_single(
+        """
+        SELECT COUNT(*) AS total
+        FROM internet_connections_customer_document_segments
+        WHERE document_id = %s
+        """,
+        (document_id,),
+    )
+    return int((row or {}).get("total") or 0)
+
+
+def _ensure_document_segments(document_id: int, extracted_text: Optional[str]) -> int:
+    existing_count = _get_document_segment_count(document_id)
+    if existing_count > 0:
+        return existing_count
+    if not str(extracted_text or "").strip():
+        return 0
+    try:
+        return _index_customer_document_segments(document_id, str(extracted_text or ""))
+    except Exception as exc:
+        logger.warning("Could not auto-index document segments for document %s: %s", document_id, exc)
+        return 0
+
+
+async def _read_invoice_text(file_path: Optional[str]) -> str:
+    if not file_path:
+        return ""
+    candidate = Path(file_path)
+    if not candidate.is_absolute():
+        candidate = Path(settings.UPLOAD_DIR).resolve() / candidate
+    if not candidate.exists() or not candidate.is_file():
+        return ""
+    try:
+        return await ollama_service._extract_text_from_file(candidate)
+    except Exception as exc:
+        logger.warning("Could not extract invoice text from %s: %s", candidate, exc)
+        return ""
+
+
+async def _build_invoice_hits(customer_id: int, customer_name: str, query: Optional[str], limit: int = 8) -> List[Dict[str, Any]]:
+    terms = _build_research_terms(customer_name, query)
+    customer_filter_sql = "NULL::INTEGER AS linked_customer_id"
+    customer_where_sql = ""
+    params: List[Any] = []
+    if table_has_column("supplier_invoices", "linked_customer_id"):
+        customer_filter_sql = "si.linked_customer_id"
+        customer_where_sql = "OR si.linked_customer_id = %s"
+        params.append(customer_id)
+
+    invoice_rows = execute_query(
+        f"""
+        SELECT
+            si.id,
+            si.invoice_number,
+            si.invoice_date,
+            si.total_amount,
+            si.currency,
+            COALESCE(v.name, si.vendor_name, 'Ukendt leverandør') AS vendor_name,
+            COALESCE(si.description, '') AS description,
+            COALESCE(si.notes, '') AS notes,
+            COALESCE(inf.file_path, si.file_path) AS file_path,
+            COALESCE(inf.original_filename, si.file_path, '') AS source_filename,
+            {customer_filter_sql}
+        FROM supplier_invoices si
+        LEFT JOIN vendors v ON v.id = si.vendor_id
+        LEFT JOIN extractions ext ON ext.extraction_id = si.extraction_id
+        LEFT JOIN incoming_files inf ON inf.file_id = ext.file_id
+        WHERE si.invoice_date >= (CURRENT_DATE - INTERVAL '18 months')
+          AND (
+              COALESCE(si.description, '') <> ''
+              OR COALESCE(si.notes, '') <> ''
+              OR COALESCE(si.file_path, '') <> ''
+              OR COALESCE(inf.file_path, '') <> ''
+              {customer_where_sql}
+          )
+        ORDER BY si.invoice_date DESC, si.id DESC
+        LIMIT 30
+        """,
+        tuple(params) if params else None,
+    ) or []
+
+    hits: List[Dict[str, Any]] = []
+    for row in invoice_rows:
+        extracted_text = await _read_invoice_text(row.get("file_path"))
+        combined_text = "\n".join(
+            part for part in [row.get("description"), row.get("notes"), extracted_text] if str(part or "").strip()
+        )
+        searchable_text = " ".join(
+            str(part or "") for part in [row.get("vendor_name"), row.get("invoice_number"), combined_text]
+        )
+        customer_hits = _count_term_hits(searchable_text, terms["customer_terms"])
+        query_hits = _count_term_hits(searchable_text, terms["query_terms"])
+        internet_hits = _count_term_hits(searchable_text, terms["internet_terms"])
+        directly_linked = row.get("linked_customer_id") == customer_id
+        if not directly_linked and customer_hits == 0 and query_hits == 0:
+            continue
+        if internet_hits == 0:
+            continue
+
+        snippets = _extract_text_snippets(
+            combined_text or searchable_text,
+            terms["query_terms"] or terms["customer_terms"] or terms["internet_terms"],
+            limit=2,
+        )
+        score = (6 if directly_linked else 0) + (customer_hits * 3) + (query_hits * 4) + internet_hits
+        hits.append(
+            {
+                "invoice_id": row.get("id"),
+                "invoice_number": row.get("invoice_number"),
+                "invoice_date": row.get("invoice_date").isoformat() if row.get("invoice_date") else None,
+                "vendor_name": row.get("vendor_name"),
+                "total_amount": float(row.get("total_amount") or 0),
+                "currency": row.get("currency") or "DKK",
+                "source_filename": row.get("source_filename"),
+                "directly_linked": directly_linked,
+                "score": score,
+                "snippets": snippets,
+            }
+        )
+
+    hits.sort(key=lambda item: (-item["score"], item.get("invoice_date") or ""))
+    return hits[:limit]
+
+
+async def _build_customer_document_hits(customer_id: int, customer_name: str, query: Optional[str]) -> Dict[str, Any]:
+    document_rows = execute_query(
+        """
+        SELECT
+            id,
+            customer_id,
+            connection_id,
+            original_filename,
+            filename,
+            file_size,
+            mime_type,
+            extracted_text,
+            notes,
+            created_at
+        FROM internet_connections_customer_documents
+        WHERE (customer_id = %s OR customer_id IS NULL)
+          AND deleted_at IS NULL
+        ORDER BY created_at DESC, id DESC
+        """,
+        (customer_id,),
+    ) or []
+
+    terms = _build_research_terms(customer_name, query)
+    documents = []
+    snippets: List[str] = []
+    matched_segments: List[Dict[str, Any]] = []
+    doc_by_id: Dict[int, Dict[str, Any]] = {}
+    for row in document_rows:
+        doc_id = int(row["id"])
+        row_dict = dict(row)
+        row_dict["segment_count"] = _ensure_document_segments(doc_id, row_dict.get("extracted_text"))
+        doc_by_id[doc_id] = row_dict
+
+    segment_rows = execute_query(
+        """
+        SELECT
+            seg.id,
+            seg.document_id,
+            seg.block_index,
+            seg.block_title,
+            seg.content,
+            seg.ip_addresses,
+            seg.cidr_blocks,
+            seg.references_json,
+            seg.socket_numbers
+        FROM internet_connections_customer_document_segments seg
+        JOIN internet_connections_customer_documents doc ON doc.id = seg.document_id
+        WHERE doc.deleted_at IS NULL
+          AND (doc.customer_id = %s OR doc.customer_id IS NULL)
+        ORDER BY doc.created_at DESC, seg.block_index ASC
+        """,
+        (customer_id,),
+    ) or []
+
+    has_query = bool(terms["query_terms"])
+    normalized_query = _normalize_text_for_match(query) if query else ""
+    match_terms = terms["query_terms"] or terms["customer_terms"] or terms["internet_terms"]
+    doc_segment_count: Dict[int, int] = {}
+    for row in segment_rows:
+        content = str(row.get("content") or "")
+        title = str(row.get("block_title") or "")
+        references = [str(item) for item in (row.get("references_json") or [])]
+        sockets = [str(item) for item in (row.get("socket_numbers") or [])]
+        cidrs = [str(item) for item in (row.get("cidr_blocks") or [])]
+        ips = [str(item) for item in (row.get("ip_addresses") or [])]
+        searchable = " ".join([title, content, " ".join(references), " ".join(sockets), " ".join(cidrs), " ".join(ips)])
+        customer_hits = _count_term_hits(searchable, terms["customer_terms"])
+        query_hits = _count_term_hits(searchable, terms["query_terms"])
+        internet_hits = _count_term_hits(searchable, terms["internet_terms"])
+        explicit_entity_hit = 0
+        phrase_hit = 0
+        title_hit = 0
+        if terms["query_terms"]:
+            explicit_entity_hit = sum(
+                1 for token in terms["query_terms"]
+                if token in _normalize_text_for_match(" ".join(ips + cidrs + references + sockets))
+            )
+            phrase_hit = 1 if normalized_query and normalized_query in _normalize_text_for_match(searchable) else 0
+            title_hit = _count_term_hits(title, terms["query_terms"])
+
+        if has_query:
+            if query_hits == 0 and explicit_entity_hit == 0 and phrase_hit == 0 and title_hit == 0:
+                continue
+        elif customer_hits == 0 and query_hits == 0 and explicit_entity_hit == 0:
+            continue
+
+        score = (customer_hits * 2) + (query_hits * 8) + internet_hits + (explicit_entity_hit * 10) + (phrase_hit * 12) + (title_hit * 6)
+        if _is_generic_segment_title(title) and explicit_entity_hit == 0 and phrase_hit == 0:
+            score -= 6
+        if has_query and query_hits > 0 and customer_hits == 0:
+            score += 4
+        if score <= 0:
+            continue
+
+        doc_id = int(row["document_id"])
+        doc_segment_count[doc_id] = doc_segment_count.get(doc_id, 0) + 1
+        segment_snippets = _extract_text_snippets(content, match_terms, limit=1)
+        snippet = segment_snippets[0] if segment_snippets else re.sub(r"\s+", " ", content[:240]).strip()
+        matched_segments.append(
+            {
+                "segment_id": int(row["id"]),
+                "document_id": doc_id,
+                "block_index": int(row.get("block_index") or 0),
+                "title": title or f"Blok {int(row.get('block_index') or 0) + 1}",
+                "score": score,
+                "snippet": snippet,
+                "ip_addresses": ips,
+                "cidr_blocks": cidrs,
+                "references": references,
+                "socket_numbers": sockets,
+            }
+        )
+        snippets.append(f"{doc_by_id.get(doc_id, {}).get('original_filename')}: {snippet}")
+
+    matched_segments.sort(key=lambda item: (-item["score"], item["document_id"], item["block_index"]))
+
+    for row in document_rows:
+        doc_id = int(row["id"])
+        row_dict = doc_by_id.get(doc_id, dict(row))
+        text = str(row_dict.get("extracted_text") or "")
+        doc_snippets = [seg["snippet"] for seg in matched_segments if seg["document_id"] == doc_id][:2]
+        matched_count = doc_segment_count.get(doc_id, 0)
+        if not doc_snippets and not has_query:
+            doc_snippets = _extract_text_snippets(text, match_terms, limit=2)
+        if has_query and matched_count <= 0:
+            continue
+        if matched_count <= 0 and row_dict.get("customer_id") != customer_id:
+            continue
+        documents.append(
+            {
+                "id": doc_id,
+                "connection_id": row_dict.get("connection_id"),
+                "original_filename": row_dict.get("original_filename"),
+                "file_size": row_dict.get("file_size"),
+                "mime_type": row_dict.get("mime_type"),
+                "notes": row_dict.get("notes"),
+                "created_at": row_dict.get("created_at").isoformat() if row_dict.get("created_at") else None,
+                "snippet_count": matched_count if has_query else doc_segment_count.get(doc_id, row_dict.get("segment_count", len(doc_snippets))),
+                "snippets": doc_snippets[:2],
+            }
+        )
+
+    return {"documents": documents, "snippets": snippets[:12], "segments": matched_segments[:16]}
+
+
+def _validate_cidr(cidr: str):
+    try:
+        return ipaddress.ip_network(cidr, strict=False)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail="Invalid CIDR notation") from exc
+
+
+def _normalize_ip_address(ip_address: str) -> str:
+    try:
+        return str(ipaddress.ip_address(str(ip_address or "").strip()))
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail="Invalid IP address") from exc
+
+
+def _normalize_match_text(value: Optional[str]) -> str:
+    normalized = str(value or "").strip().upper()
+    normalized = normalized.replace("Æ", "AE").replace("Ø", "OE").replace("Å", "AA")
+    return "".join(ch for ch in normalized if ch.isalnum())
+
+
+def _build_ip_range_payload(range_row: dict, address_rows: Optional[list[dict]] = None) -> dict:
+    payload = dict(range_row)
+    network = None
+    cidr = range_row.get("cidr")
+    if cidr:
+        try:
+            network = ipaddress.ip_network(cidr, strict=False)
+        except ValueError:
+            network = None
+
+    payload["network_address"] = str(network.network_address) if network else None
+    payload["broadcast_address"] = str(network.broadcast_address) if network else None
+    payload["prefix_length"] = int(network.prefixlen) if network else None
+    payload["total_hosts"] = int(network.num_addresses) if network else 0
+
+    if network and network.num_addresses > 1:
+        usable_hosts = max(network.num_addresses - 2, 0)
+    elif network:
+        usable_hosts = 1 if network.num_addresses == 1 else 0
+    else:
+        usable_hosts = 0
+
+    payload["usable_hosts"] = usable_hosts
+    range_addresses = address_rows or []
+    payload["used_addresses"] = sum(
+        1 for row in range_addresses if str(row.get("status", "available")).lower() != "available"
+    )
+    payload["available_addresses"] = max(usable_hosts - payload["used_addresses"], 0)
+    return payload
+
+
+def _range_alignment_for_connection(connection: Dict[str, Any], range_item: Dict[str, Any]) -> Dict[str, Any]:
+    connection_address = _normalize_match_text(connection.get("address"))
+    service_address = _normalize_match_text(range_item.get("service_address"))
+    connection_customer_id = connection.get("customer_id")
+    range_customer_id = range_item.get("customer_id")
+    is_shared_head = bool(connection.get("allocation_model") == "shared" and not connection.get("parent_id"))
+
+    if is_shared_head:
+        return {"belongs_to_connection": True, "alignment_reason": "shared_head", "alignment_warning": None}
+    if connection_address and service_address and connection_address == service_address:
+        return {"belongs_to_connection": True, "alignment_reason": "service_address", "alignment_warning": None}
+    if connection_customer_id and range_customer_id and int(connection_customer_id) == int(range_customer_id):
+        return {"belongs_to_connection": True, "alignment_reason": "customer", "alignment_warning": None}
+    if not service_address and not range_customer_id:
+        return {"belongs_to_connection": True, "alignment_reason": "unassigned", "alignment_warning": None}
+
+    warning = "Range matcher ikke forbindelsens adresse/kunde"
+    if range_item.get("service_address"):
+        warning = f"Range ligger paa anden serviceadresse: {range_item.get('service_address')}"
+    elif range_item.get("customer_name"):
+        warning = f"Range er bundet til anden kunde: {range_item.get('customer_name')}"
+    return {"belongs_to_connection": False, "alignment_reason": "mismatch", "alignment_warning": warning}
+
+
+def _create_history_entry(connection_id: int, event_type: str, summary: str, details: Optional[dict] = None):
+    execute_query(
+        """
+        INSERT INTO internet_connections_history (connection_id, event_type, summary, details)
+        VALUES (%s, %s, %s, %s)
+        """,
+        (connection_id, event_type, summary, Json(details or {})),
+    )
+
+
+def _create_ip_addresses_for_range(range_id: int, cidr: str):
+    network = _validate_cidr(cidr)
+    addresses = []
+    for host in list(network.hosts()):
+        addresses.append(str(host))
+
+    if not addresses:
+        return []
+
+    created = []
+    for ip_address in addresses:
+        existing = execute_query(
+            """
+            SELECT *
+            FROM internet_connections_ip_addresses
+            WHERE ip_address = %s
+              AND deleted_at IS NULL
+            LIMIT 1
+            """,
+            (ip_address,),
+        ) or []
+        if existing:
+            continue
+        rows = execute_query(
+            """
+            INSERT INTO internet_connections_ip_addresses (range_id, ip_address, status, assigned_to, assigned_type, comment)
+            VALUES (%s, %s, %s, %s, %s, %s)
+            RETURNING *
+            """,
+            (range_id, ip_address, "available", None, None, "Auto-generated from CIDR"),
+        ) or []
+        if rows:
+            created.append(dict(rows[0]))
+    return created
+
+
+def _get_contract_status(contract_end):
+    if not contract_end:
+        return "unknown"
+    if isinstance(contract_end, str):
+        try:
+            contract_end = date.fromisoformat(contract_end)
+        except ValueError:
+            return "unknown"
+    elif hasattr(contract_end, "date"):
+        contract_end = contract_end.date()
+    return "active" if contract_end >= date.today() else "expired"
+
+
+def _value_type_label(value_type: Optional[str]) -> str:
+    labels = {
+        "subscription": "Abonnement",
+        "bmc_networks": "BMC Networks",
+        "delefiber": "Delefiber",
+        "other": "Anden",
+    }
+    return labels.get(str(value_type or "").lower(), "Anden")
+
+
+def _allocation_model_label(allocation_model: Optional[str]) -> str:
+    labels = {
+        "dedicated": "Dedikeret",
+        "shared": "Delt",
+    }
+    return labels.get(str(allocation_model or "").lower(), "Dedikeret")
+
+
+def _normalize_connection_payload(payload: Dict[str, Any]) -> Dict[str, Any]:
+    normalized = dict(payload)
+    address = str(normalized.get("address") or "").strip() or None
+    allocation_model = str(normalized.get("allocation_model") or "dedicated").strip().lower()
+    value_type = str(normalized.get("value_type") or "other").strip().lower()
+    value_label = str(normalized.get("value_label") or "").strip() or None
+    subscription_id = normalized.get("subscription_id")
+
+    if not address:
+        raise HTTPException(status_code=400, detail="address is required for internet connections")
+
+    if allocation_model not in ALLOWED_ALLOCATION_MODELS:
+        raise HTTPException(status_code=400, detail="allocation_model must be dedicated or shared")
+    if value_type not in ALLOWED_VALUE_TYPES:
+        raise HTTPException(status_code=400, detail="value_type must be subscription, bmc_networks, delefiber or other")
+
+    if value_type == "subscription":
+        if not subscription_id:
+            raise HTTPException(status_code=400, detail="subscription_id is required when value_type is subscription")
+    else:
+        subscription_id = None
+
+    if value_type == "other":
+        if not value_label:
+            value_label = "Mangler klassifikation"
+    else:
+        value_label = None
+
+    normalized["address"] = address
+    normalized["allocation_model"] = allocation_model
+    normalized["value_type"] = value_type
+    normalized["value_label"] = value_label
+    normalized["subscription_id"] = subscription_id
+    return normalized
+
+
+def _connection_select_sql(where_sql: str = "") -> str:
+    return f"""
+        SELECT
+            ic.id,
+            ic.parent_id,
+            ic.name,
+            ic.provider,
+            ic.customer_id,
+            c.name AS customer_name,
+            parent.name AS parent_name,
+            parent.allocation_model AS parent_allocation_model,
+            parent.value_type AS parent_value_type,
+            ic.address,
+            ic.status,
+            ic.monthly_cost,
+            ic.sales_price,
+            (COALESCE(ic.sales_price, 0) - COALESCE(ic.monthly_cost, 0)) AS margin_amount,
+            ic.technology,
+            ic.connection_type,
+            ic.circuit_number,
+            ic.speed_mbps,
+            ic.upload_mbps,
+            ic.download_mbps,
+            ic.monitoring_url,
+            ic.contract_start,
+            ic.contract_end,
+            ic.allocation_model,
+            ic.value_type,
+            ic.value_label,
+            ic.subscription_id,
+            sub.subscription_number,
+            sub.product_name AS subscription_product_name,
+            subc.name AS subscription_customer_name,
+            COALESCE(ip_stats.range_count, 0) AS ip_range_count,
+            COALESCE(ip_stats.total_addresses, 0) AS total_ip_addresses,
+            COALESCE(ip_stats.in_use_addresses, 0) AS in_use_ip_addresses,
+            COALESCE(ip_stats.reserved_addresses, 0) AS reserved_ip_addresses,
+            COALESCE(ip_stats.available_addresses, 0) AS available_ip_addresses,
+            COALESCE(child_stats.bmcnet_child_count, 0) AS bmcnet_child_count,
+            COALESCE(child_stats.bmcnet_child_active_count, 0) AS bmcnet_child_active_count,
+            COALESCE(child_stats.bmcnet_child_sales_price, 0) AS bmcnet_child_sales_price,
+            COALESCE(child_stats.bmcnet_child_monthly_cost, 0) AS bmcnet_child_monthly_cost,
+            COALESCE(child_stats.bmcnet_child_margin_amount, 0) AS bmcnet_child_margin_amount,
+            COALESCE(child_stats.bmcnet_child_ip_count, 0) AS bmcnet_child_ip_count
+        FROM internet_connections_connections ic
+        LEFT JOIN customers c ON c.id = ic.customer_id
+        LEFT JOIN internet_connections_connections parent ON parent.id = ic.parent_id
+        LEFT JOIN sag_subscriptions sub ON sub.id = ic.subscription_id
+        LEFT JOIN customers subc ON subc.id = sub.customer_id
+        LEFT JOIN (
+            SELECT
+                ir.connection_id,
+                COUNT(DISTINCT ir.id) FILTER (WHERE ir.deleted_at IS NULL) AS range_count,
+                COUNT(ipa.id) FILTER (WHERE ipa.deleted_at IS NULL) AS total_addresses,
+                COUNT(ipa.id) FILTER (WHERE ipa.deleted_at IS NULL AND ipa.status = 'in_use') AS in_use_addresses,
+                COUNT(ipa.id) FILTER (WHERE ipa.deleted_at IS NULL AND ipa.status = 'reserved') AS reserved_addresses,
+                COUNT(ipa.id) FILTER (WHERE ipa.deleted_at IS NULL AND ipa.status = 'available') AS available_addresses
+            FROM internet_connections_ip_ranges ir
+            LEFT JOIN internet_connections_ip_addresses ipa ON ipa.range_id = ir.id
+            WHERE ir.deleted_at IS NULL
+            GROUP BY ir.connection_id
+        ) ip_stats ON ip_stats.connection_id = ic.id
+        LEFT JOIN (
+            SELECT
+                child.parent_id AS connection_id,
+                COUNT(*) FILTER (WHERE child.deleted_at IS NULL AND child.value_type = 'subscription') AS bmcnet_child_count,
+                COUNT(*) FILTER (
+                    WHERE child.deleted_at IS NULL
+                      AND child.value_type = 'subscription'
+                      AND child.status = 'active'
+                ) AS bmcnet_child_active_count,
+                COALESCE(SUM(child.sales_price) FILTER (
+                    WHERE child.deleted_at IS NULL
+                      AND child.value_type = 'subscription'
+                ), 0) AS bmcnet_child_sales_price,
+                COALESCE(SUM(child.monthly_cost) FILTER (
+                    WHERE child.deleted_at IS NULL
+                      AND child.value_type = 'subscription'
+                ), 0) AS bmcnet_child_monthly_cost,
+                COALESCE(SUM(COALESCE(child.sales_price, 0) - COALESCE(child.monthly_cost, 0)) FILTER (
+                    WHERE child.deleted_at IS NULL
+                      AND child.value_type = 'subscription'
+                ), 0) AS bmcnet_child_margin_amount,
+                COALESCE(SUM(
+                    COALESCE(child_ip_stats.in_use_addresses, 0) + COALESCE(child_ip_stats.reserved_addresses, 0)
+                ) FILTER (
+                    WHERE child.deleted_at IS NULL
+                      AND child.value_type = 'subscription'
+                ), 0) AS bmcnet_child_ip_count
+            FROM internet_connections_connections child
+            LEFT JOIN (
+                SELECT
+                    ir.connection_id,
+                    COUNT(ipa.id) FILTER (WHERE ipa.deleted_at IS NULL AND ipa.status = 'in_use') AS in_use_addresses,
+                    COUNT(ipa.id) FILTER (WHERE ipa.deleted_at IS NULL AND ipa.status = 'reserved') AS reserved_addresses
+                FROM internet_connections_ip_ranges ir
+                LEFT JOIN internet_connections_ip_addresses ipa ON ipa.range_id = ir.id
+                WHERE ir.deleted_at IS NULL
+                GROUP BY ir.connection_id
+            ) child_ip_stats ON child_ip_stats.connection_id = child.id
+            WHERE child.parent_id IS NOT NULL
+            GROUP BY child.parent_id
+        ) child_stats ON child_stats.connection_id = ic.id
+        WHERE ic.deleted_at IS NULL
+        {where_sql}
+    """
+
+
+def _decorate_connection_row(row: dict) -> dict:
+    item = dict(row)
+    value_label = str(item.get("value_label") or "").strip().lower()
+    is_bmcnet = bool(
+        item.get("parent_id")
+        and str(item.get("parent_allocation_model") or "").lower() == "shared"
+        and (
+            item.get("value_type") == "subscription"
+            or value_label == "bmcnet"
+            or value_label == "bmc networks"
+        )
+    )
+    item["value_type_label"] = _value_type_label(item.get("value_type"))
+    item["allocation_model_label"] = _allocation_model_label(item.get("allocation_model"))
+    item["is_shared_head"] = bool(item.get("allocation_model") == "shared" and not item.get("parent_id"))
+    item["is_bmcnet_connection"] = is_bmcnet
+    return item
+
+
+def _load_bmcnet_children(parent_connection_id: int) -> List[Dict[str, Any]]:
+    rows = execute_query(
+        _connection_select_sql(
+            """
+            AND ic.parent_id = %s
+            AND parent.allocation_model = 'shared'
+            AND (
+                ic.value_type = 'subscription'
+                OR LOWER(COALESCE(ic.value_label, '')) IN ('bmcnet', 'bmc networks')
+            )
+            """
+        )
+        + " ORDER BY c.name ASC NULLS LAST, ic.name ASC",
+        (parent_connection_id,),
+    ) or []
+    return [_decorate_connection_row(dict(row)) for row in rows]
+
+
+def _build_bmcnet_summary(children: List[Dict[str, Any]]) -> Dict[str, Any]:
+    return {
+        "connection_count": len(children),
+        "active_connection_count": sum(1 for child in children if str(child.get("status") or "").lower() == "active"),
+        "sales_price": float(sum(float(child.get("sales_price") or 0) for child in children)),
+        "monthly_cost": float(sum(float(child.get("monthly_cost") or 0) for child in children)),
+        "margin_amount": float(sum(float(child.get("margin_amount") or 0) for child in children)),
+        "ip_in_use_count": int(
+            sum(
+                int(child.get("in_use_ip_addresses") or 0) + int(child.get("reserved_ip_addresses") or 0)
+                for child in children
+            )
+        ),
+    }
+
+
+class ConnectionCreatePayload(BaseModel):
+    name: str
+    provider: Optional[str] = None
+    customer_id: Optional[int] = None
+    parent_id: Optional[int] = None
+    address: Optional[str] = None
+    status: str = "active"
+    monthly_cost: float = 0
+    sales_price: float = 0
+    technology: Optional[str] = None
+    connection_type: str = "fiber"
+    circuit_number: Optional[str] = None
+    speed_mbps: Optional[int] = None
+    upload_mbps: Optional[int] = None
+    download_mbps: Optional[int] = None
+    monitoring_url: Optional[str] = None
+    contract_start: Optional[date] = None
+    contract_end: Optional[date] = None
+    notes: Optional[str] = None
+    allocation_model: str = "dedicated"
+    value_type: str = "other"
+    value_label: Optional[str] = None
+    subscription_id: Optional[int] = None
+
+
+class ConnectionUpdatePayload(BaseModel):
+    name: Optional[str] = None
+    provider: Optional[str] = None
+    customer_id: Optional[int] = None
+    parent_id: Optional[int] = None
+    address: Optional[str] = None
+    status: Optional[str] = None
+    monthly_cost: Optional[float] = None
+    sales_price: Optional[float] = None
+    technology: Optional[str] = None
+    connection_type: Optional[str] = None
+    circuit_number: Optional[str] = None
+    speed_mbps: Optional[int] = None
+    upload_mbps: Optional[int] = None
+    download_mbps: Optional[int] = None
+    monitoring_url: Optional[str] = None
+    contract_start: Optional[date] = None
+    contract_end: Optional[date] = None
+    notes: Optional[str] = None
+    allocation_model: Optional[str] = None
+    value_type: Optional[str] = None
+    value_label: Optional[str] = None
+    subscription_id: Optional[int] = None
+
+
+class PricingCreatePayload(BaseModel):
+    effective_from: date
+    purchase_price: float = 0
+    sales_price: float = 0
+    notes: Optional[str] = None
+
+
+class IpRangeCreatePayload(BaseModel):
+    name: str
+    cidr: str
+    description: Optional[str] = None
+    provider_reference: Optional[str] = None
+    contract_number: Optional[str] = None
+    customer_id: Optional[int] = None
+    service_address: Optional[str] = None
+    monthly_cost: float = 0
+    sales_price: float = 0
+
+
+class IpRangeUpdatePayload(BaseModel):
+    name: Optional[str] = None
+    description: Optional[str] = None
+    provider_reference: Optional[str] = None
+    contract_number: Optional[str] = None
+    customer_id: Optional[int] = None
+    service_address: Optional[str] = None
+    monthly_cost: Optional[float] = None
+    sales_price: Optional[float] = None
+
+
+class IpAddressCreatePayload(BaseModel):
+    range_id: int
+    ip_address: str
+    status: str = "available"
+    assigned_to: Optional[str] = None
+    assigned_type: Optional[str] = None
+    assigned_customer_id: Optional[int] = None
+    assigned_connection_id: Optional[int] = None
+    comment: Optional[str] = None
+
+
+class IpAddressUpdatePayload(BaseModel):
+    status: str = "available"
+    assigned_to: Optional[str] = None
+    assigned_type: Optional[str] = None
+    assigned_customer_id: Optional[int] = None
+    assigned_connection_id: Optional[int] = None
+    comment: Optional[str] = None
+
+
+class SubscriptionIpAllocationPayload(BaseModel):
+    subscription_item_id: int
+    range_id: int
+    requested_cidr: Optional[str] = None
+
+
+class SubscriptionProvisionPayload(BaseModel):
+    shared_connection_id: int
+    internet_item_id: Optional[int] = None
+    ip_allocations: List[SubscriptionIpAllocationPayload] = []
+
+
+class QuickBmcnetCreatePayload(BaseModel):
+    customer_id: int
+    case_title: Optional[str] = None
+    service_label: Optional[str] = None
+    address: Optional[str] = None
+    billing_interval: str = "monthly"
+    billing_day: int = 1
+    start_date: date
+    internet_product_id: int
+    internet_unit_price: Optional[float] = None
+    ip_product_id: Optional[int] = None
+    ip_unit_price: Optional[float] = None
+    notes: Optional[str] = None
+    range_id: Optional[int] = None
+    ip_address_id: Optional[int] = None
+    mark_gateway: bool = False
+
+
+def _load_subscription(subscription_id: int) -> Dict[str, Any]:
+    subscription = execute_query_single(
+        """
+        SELECT
+            s.id,
+            s.subscription_number,
+            s.sag_id,
+            s.customer_id,
+            c.name AS customer_name,
+            s.product_name,
+            s.billing_interval,
+            s.price,
+            s.status,
+            s.start_date
+        FROM sag_subscriptions s
+        LEFT JOIN customers c ON c.id = s.customer_id
+        WHERE s.id = %s
+        """,
+        (subscription_id,),
+    )
+    if not subscription:
+        raise HTTPException(status_code=404, detail="Subscription not found")
+    return dict(subscription)
+
+
+def _load_subscription_line_items(subscription_id: int) -> List[Dict[str, Any]]:
+    rows = execute_query(
+        """
+        SELECT
+            i.id,
+            i.line_no,
+            i.product_id,
+            p.name AS product_name,
+            p.type AS product_type,
+            p.attributes_json,
+            i.description,
+            i.quantity,
+            i.unit_price,
+            i.line_total
+        FROM sag_subscription_items i
+        LEFT JOIN products p ON p.id = i.product_id
+        WHERE i.subscription_id = %s
+        ORDER BY i.line_no ASC, i.id ASC
+        """,
+        (subscription_id,),
+    ) or []
+    return [dict(row) for row in rows]
+
+
+def _load_subscription_connection(subscription_id: int) -> Optional[Dict[str, Any]]:
+    rows = execute_query(
+        _connection_select_sql(" AND ic.subscription_id = %s ") + " ORDER BY ic.id ASC LIMIT 1",
+        (subscription_id,),
+    ) or []
+    return _decorate_connection_row(dict(rows[0])) if rows else None
+
+
+def _resolve_group_id_by_name_tokens(tokens: List[str]) -> Optional[int]:
+    lowered = [str(token or "").strip().lower() for token in tokens if str(token or "").strip()]
+    if not lowered:
+        return None
+    clauses = " OR ".join(["LOWER(name) LIKE %s" for _ in lowered])
+    params = tuple(f"%{token}%" for token in lowered)
+    row = execute_query_single(
+        f"""
+        SELECT id
+        FROM groups
+        WHERE {clauses}
+        ORDER BY id
+        LIMIT 1
+        """,
+        params,
+    )
+    return int(row["id"]) if row and row.get("id") else None
+
+
+def _load_connection_ranges(connection_id: int) -> List[Dict[str, Any]]:
+    rows = execute_query(
+        """
+        SELECT
+            ir.*,
+            c.name AS customer_name,
+            COUNT(ipa.id) FILTER (WHERE ipa.deleted_at IS NULL) AS total_addresses,
+            COUNT(ipa.id) FILTER (WHERE ipa.deleted_at IS NULL AND ipa.status = 'available') AS available_addresses,
+            COUNT(ipa.id) FILTER (WHERE ipa.deleted_at IS NULL AND ipa.status = 'reserved') AS reserved_addresses,
+            COUNT(ipa.id) FILTER (WHERE ipa.deleted_at IS NULL AND ipa.status = 'in_use') AS in_use_addresses
+        FROM internet_connections_ip_ranges ir
+        LEFT JOIN customers c ON c.id = ir.customer_id
+        LEFT JOIN internet_connections_ip_addresses ipa ON ipa.range_id = ir.id
+        WHERE ir.connection_id = %s
+          AND ir.deleted_at IS NULL
+        GROUP BY ir.id, c.name
+        ORDER BY ir.id ASC
+        """,
+        (connection_id,),
+    ) or []
+    payload: List[Dict[str, Any]] = []
+    for row in rows:
+        item = _build_ip_range_payload(dict(row))
+        item["is_fully_available"] = bool(
+            item.get("total_addresses", 0) > 0 and item.get("available_addresses", 0) == item.get("total_addresses", 0)
+        )
+        payload.append(item)
+    return payload
+
+
+def _build_provisioning_candidates(range_item: Dict[str, Any], required_prefixes: List[int]) -> List[Dict[str, Any]]:
+    if not required_prefixes:
+        return []
+    if range_item.get("customer_id") is not None:
+        return []
+    if not range_item.get("is_fully_available"):
+        return []
+
+    cidr = str(range_item.get("cidr") or "").strip()
+    if not cidr:
+        return []
+
+    try:
+        network = ipaddress.ip_network(cidr, strict=False)
+    except ValueError:
+        return []
+
+    candidates: List[Dict[str, Any]] = []
+    seen: set[tuple[int, str]] = set()
+    for requested_prefix in required_prefixes:
+        try:
+            prefix_value = int(requested_prefix)
+        except (TypeError, ValueError):
+            continue
+        if prefix_value < network.prefixlen:
+            continue
+        if prefix_value == network.prefixlen:
+            candidate = dict(range_item)
+            candidate["range_id"] = int(range_item["id"])
+            candidate["source_range_id"] = int(range_item["id"])
+            candidate["source_cidr"] = cidr
+            candidate["requested_cidr"] = cidr
+            candidate["is_derived_candidate"] = False
+            key = (candidate["source_range_id"], candidate["requested_cidr"])
+            if key not in seen:
+                candidates.append(candidate)
+                seen.add(key)
+            continue
+
+        for subnet in network.subnets(new_prefix=prefix_value):
+            requested_cidr = str(subnet)
+            key = (int(range_item["id"]), requested_cidr)
+            if key in seen:
+                continue
+            usable_hosts = max(subnet.num_addresses - 2, 0) if subnet.num_addresses > 1 else int(subnet.num_addresses)
+            candidates.append(
+                {
+                    "id": f"{range_item['id']}:{requested_cidr}",
+                    "range_id": int(range_item["id"]),
+                    "source_range_id": int(range_item["id"]),
+                    "source_cidr": cidr,
+                    "requested_cidr": requested_cidr,
+                    "cidr": requested_cidr,
+                    "name": f"{range_item.get('name') or 'Range'} -> {requested_cidr}",
+                    "description": range_item.get("description"),
+                    "provider_reference": range_item.get("provider_reference"),
+                    "contract_number": range_item.get("contract_number"),
+                    "customer_id": None,
+                    "customer_name": None,
+                    "service_address": range_item.get("service_address"),
+                    "monthly_cost": 0,
+                    "sales_price": 0,
+                    "network_address": str(subnet.network_address),
+                    "broadcast_address": str(subnet.broadcast_address),
+                    "prefix_length": int(subnet.prefixlen),
+                    "total_hosts": int(subnet.num_addresses),
+                    "usable_hosts": usable_hosts,
+                    "total_addresses": usable_hosts,
+                    "available_addresses": usable_hosts,
+                    "reserved_addresses": 0,
+                    "in_use_addresses": 0,
+                    "used_addresses": 0,
+                    "is_fully_available": True,
+                    "is_derived_candidate": True,
+                }
+            )
+            seen.add(key)
+    return candidates
+
+
+def _load_shared_heads_for_provisioning(required_prefixes: List[int]) -> List[Dict[str, Any]]:
+    rows = execute_query(
+        _connection_select_sql(
+            """
+            AND ic.allocation_model = 'shared'
+            AND ic.parent_id IS NULL
+            """
+        )
+        + " ORDER BY ic.address ASC NULLS LAST, ic.name ASC",
+    ) or []
+    heads: List[Dict[str, Any]] = []
+    for row in rows:
+        head = _decorate_connection_row(dict(row))
+        ranges = _load_connection_ranges(int(head["id"]))
+        matching_ranges = []
+        for range_item in ranges:
+            matching_ranges.extend(_build_provisioning_candidates(range_item, required_prefixes))
+        head["available_matching_ranges"] = matching_ranges
+        head["available_matching_range_count"] = len(matching_ranges)
+        heads.append(head)
+    return heads
+
+
+@router.get("/internet-connections/health")
+async def internet_connections_health():
+    return {"status": "healthy", "service": "internet-connections-module"}
+
+
+@router.get("/internet-connections", response_model=List[dict])
+async def list_connections(
+    q: Optional[str] = Query(None),
+    customer_id: Optional[int] = Query(None),
+    provider: Optional[str] = Query(None),
+    status: Optional[str] = Query(None),
+    allocation_model: Optional[str] = Query(None),
+    value_type: Optional[str] = Query(None),
+    shared_only: bool = Query(False),
+    bmcnet_only: bool = Query(False),
+):
+    query = _connection_select_sql()
+    params: list[object] = []
+    if q:
+        query += " AND (ic.name ILIKE %s OR ic.provider ILIKE %s OR ic.address ILIKE %s OR c.name ILIKE %s OR ic.circuit_number ILIKE %s OR sub.subscription_number ILIKE %s OR sub.product_name ILIKE %s)"
+        term = f"%{q}%"
+        params.extend([term, term, term, term, term, term, term])
+    if customer_id:
+        query += " AND ic.customer_id = %s"
+        params.append(customer_id)
+    if provider:
+        query += " AND ic.provider ILIKE %s"
+        params.append(f"%{provider}%")
+    if status:
+        query += " AND ic.status = %s"
+        params.append(status)
+    if allocation_model:
+        query += " AND ic.allocation_model = %s"
+        params.append(allocation_model)
+    if value_type:
+        query += " AND ic.value_type = %s"
+        params.append(value_type)
+    if shared_only:
+        query += " AND ic.allocation_model = 'shared' AND ic.parent_id IS NULL"
+    if bmcnet_only:
+        query += """
+            AND ic.parent_id IS NOT NULL
+            AND parent.allocation_model = 'shared'
+            AND (
+                ic.value_type = 'subscription'
+                OR LOWER(COALESCE(ic.value_label, '')) IN ('bmcnet', 'bmc networks')
+            )
+        """
+    query += " ORDER BY c.name ASC NULLS LAST, ic.name ASC"
+    try:
+        rows = execute_query(query, tuple(params) if params else ()) or []
+    except Exception as exc:
+        logger.warning("Failed to load internet connections: %s", exc)
+        return []
+    return [_decorate_connection_row(dict(row)) for row in rows]
+
+
+@router.post("/internet-connections", response_model=dict)
+async def create_connection(payload: ConnectionCreatePayload):
+    normalized = _normalize_connection_payload(payload.model_dump())
+    try:
+        rows = execute_query(
+            """
+            INSERT INTO internet_connections_connections (
+                parent_id, name, provider, customer_id, address, status, monthly_cost, sales_price, technology,
+                connection_type, circuit_number, speed_mbps, upload_mbps, download_mbps, monitoring_url,
+                contract_start, contract_end, notes, allocation_model, value_type, value_label, subscription_id
+            )
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+            RETURNING *
+            """,
+            (
+                normalized.get("parent_id"),
+                normalized.get("name"),
+                normalized.get("provider"),
+                normalized.get("customer_id"),
+                normalized.get("address"),
+                normalized.get("status"),
+                normalized.get("monthly_cost"),
+                normalized.get("sales_price"),
+                normalized.get("technology"),
+                normalized.get("connection_type"),
+                normalized.get("circuit_number"),
+                normalized.get("speed_mbps"),
+                normalized.get("upload_mbps"),
+                normalized.get("download_mbps"),
+                normalized.get("monitoring_url"),
+                normalized.get("contract_start"),
+                normalized.get("contract_end"),
+                normalized.get("notes"),
+                normalized.get("allocation_model"),
+                normalized.get("value_type"),
+                normalized.get("value_label"),
+                normalized.get("subscription_id"),
+            ),
+        )
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.exception("Failed to create internet connection")
+        raise HTTPException(status_code=500, detail=f"Kunne ikke oprette forbindelse: {exc}") from exc
+    if not rows:
+        raise HTTPException(status_code=500, detail="Failed to create connection")
+    connection = dict(rows[0])
+    _create_history_entry(
+        int(connection["id"]),
+        "connection_created",
+        f"Oprettede forbindelse {payload.name}",
+        {
+            "provider": normalized.get("provider"),
+            "customer_id": normalized.get("customer_id"),
+            "parent_id": normalized.get("parent_id"),
+            "status": normalized.get("status"),
+            "allocation_model": normalized.get("allocation_model"),
+            "value_type": normalized.get("value_type"),
+            "subscription_id": normalized.get("subscription_id"),
+        },
+    )
+    return connection
+
+
+@router.put("/internet-connections/{connection_id:int}", response_model=dict)
+async def update_connection(connection_id: int, payload: ConnectionUpdatePayload):
+    existing_rows = execute_query(
+        _connection_select_sql(" AND ic.id = %s "),
+        (connection_id,),
+    ) or []
+    if not existing_rows:
+        raise HTTPException(status_code=404, detail="Connection not found")
+
+    existing = dict(existing_rows[0])
+    update_values = payload.model_dump(exclude_unset=True)
+    if not update_values:
+        return _decorate_connection_row(existing)
+
+    merged_values = dict(existing)
+    merged_values.update(update_values)
+    if (
+        str(merged_values.get("value_type") or "").strip().lower() == "other"
+        and not str(merged_values.get("value_label") or "").strip()
+    ):
+        merged_values["value_label"] = "Mangler klassifikation"
+    normalized = _normalize_connection_payload(merged_values)
+
+    set_parts = []
+    params: list[object] = []
+    changed: dict[str, object] = {}
+    allowed_fields = set(update_values.keys()) | {"allocation_model", "value_type", "value_label", "subscription_id"}
+    for field in allowed_fields:
+        value = normalized.get(field)
+        set_parts.append(f"{field} = %s")
+        params.append(value)
+        if existing.get(field) != value:
+            changed[field] = value
+
+    params.append(connection_id)
+    try:
+        rows = execute_query(
+            f"""
+            UPDATE internet_connections_connections
+            SET {", ".join(set_parts)}, updated_at = CURRENT_TIMESTAMP
+            WHERE id = %s AND deleted_at IS NULL
+            RETURNING *
+            """,
+            tuple(params),
+        ) or []
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.exception("Failed to update internet connection %s", connection_id)
+        raise HTTPException(status_code=500, detail=f"Kunne ikke gemme forbindelse: {exc}") from exc
+    if not rows:
+        raise HTTPException(status_code=500, detail="Failed to update connection")
+
+    if changed:
+        _create_history_entry(
+            connection_id,
+            "connection_updated",
+            f"Opdaterede forbindelse {rows[0].get('name')}",
+            changed,
+        )
+    return dict(rows[0])
+
+
+@router.get("/internet-connections/contracts")
+async def list_contracts(status: Optional[str] = Query(None), provider: Optional[str] = Query(None)):
+    query = """
+        SELECT
+            id,
+            name,
+            provider,
+            contract_start,
+            contract_end,
+            status,
+            sales_price,
+            allocation_model,
+            value_type,
+            subscription_id
+        FROM internet_connections_connections
+        WHERE deleted_at IS NULL
+    """
+    params: list[object] = []
+
+    if status:
+        query += " AND status = %s"
+        params.append(status)
+    if provider:
+        query += " AND provider ILIKE %s"
+        params.append(f"%{provider}%")
+
+    query += " ORDER BY contract_end IS NULL, contract_end ASC, name ASC"
+    try:
+        rows = execute_query(query, tuple(params) if params else ()) or []
+    except Exception as exc:
+        logger.warning("Failed to load contract overview: %s", exc)
+        return []
+
+    payload = []
+    for row in rows:
+        item = dict(row)
+        item["contract_status"] = _get_contract_status(item.get("contract_end"))
+        item["value_type_label"] = _value_type_label(item.get("value_type"))
+        item["allocation_model_label"] = _allocation_model_label(item.get("allocation_model"))
+        payload.append(item)
+    return payload
+
+
+@router.get("/internet-connections/{connection_id:int}", response_model=dict)
+async def get_connection(connection_id: int):
+    rows = execute_query(
+        _connection_select_sql(" AND ic.id = %s "),
+        (connection_id,),
+    ) or []
+    if not rows:
+        raise HTTPException(status_code=404, detail="Connection not found")
+    connection = _decorate_connection_row(dict(rows[0]))
+    if connection.get("is_shared_head"):
+        children = _load_bmcnet_children(connection_id)
+        connection["bmcnet_summary"] = _build_bmcnet_summary(children)
+    else:
+        connection["bmcnet_summary"] = _build_bmcnet_summary([])
+    return connection
+
+
+@router.get("/internet-connections/{connection_id:int}/children", response_model=List[dict])
+async def list_connection_children(connection_id: int, bmcnet_only: bool = Query(False)):
+    where_parts = [" AND ic.parent_id = %s "]
+    if bmcnet_only:
+        where_parts.append(
+            """
+            AND parent.allocation_model = 'shared'
+            AND (
+                ic.value_type = 'subscription'
+                OR LOWER(COALESCE(ic.value_label, '')) IN ('bmcnet', 'bmc networks')
+            )
+            """
+        )
+    rows = execute_query(
+        _connection_select_sql("".join(where_parts)) + " ORDER BY c.name ASC NULLS LAST, ic.name ASC",
+        (connection_id,),
+    ) or []
+    return [_decorate_connection_row(dict(row)) for row in rows]
+
+
+@router.get("/internet-connections/pricing/summary")
+async def pricing_summary():
+    try:
+        rows = execute_query(
+            """
+            SELECT
+                COUNT(*) AS total_connections,
+                COUNT(*) FILTER (WHERE status = 'active') AS active_connections,
+                COUNT(*) FILTER (WHERE allocation_model = 'shared' AND parent_id IS NULL) AS shared_head_connections,
+                COALESCE(SUM(monthly_cost), 0) AS total_purchase_cost,
+                COALESCE(SUM(sales_price), 0) AS total_sales_price,
+                COALESCE(SUM(COALESCE(sales_price, 0) - COALESCE(monthly_cost, 0)), 0) AS total_margin
+            FROM internet_connections_connections
+            WHERE deleted_at IS NULL
+            """,
+        ) or []
+    except Exception as exc:
+        logger.warning("Failed to load pricing summary: %s", exc)
+        return {"total_connections": 0, "active_connections": 0, "shared_head_connections": 0, "total_purchase_cost": 0, "total_sales_price": 0, "total_margin": 0}
+    return dict(rows[0]) if rows else {"total_connections": 0, "active_connections": 0, "shared_head_connections": 0, "total_purchase_cost": 0, "total_sales_price": 0, "total_margin": 0}
+
+
+@router.get("/internet-connections/subscription-options", response_model=List[dict])
+async def subscription_options(q: Optional[str] = Query(None), status: str = Query("active")):
+    params: List[Any] = []
+    where = ["1=1"]
+    if status and status != "all":
+        where.append("s.status = %s")
+        params.append(status)
+    if q:
+        term = f"%{q}%"
+        where.append("(s.subscription_number ILIKE %s OR s.product_name ILIKE %s OR c.name ILIKE %s)")
+        params.extend([term, term, term])
+    rows = execute_query(
+        f"""
+        SELECT
+            s.id,
+            s.subscription_number,
+            s.product_name,
+            s.customer_id,
+            c.name AS customer_name,
+            s.status
+        FROM sag_subscriptions s
+        LEFT JOIN customers c ON c.id = s.customer_id
+        WHERE {" AND ".join(where)}
+        ORDER BY s.start_date DESC NULLS LAST, s.id DESC
+        LIMIT 50
+        """,
+        tuple(params) if params else (),
+    ) or []
+    return [dict(row) for row in rows]
+
+
+@router.get("/internet-connections/subscriptions/{subscription_id}/provisioning")
+async def get_subscription_provisioning(subscription_id: int):
+    subscription = _load_subscription(subscription_id)
+    line_items = _load_subscription_line_items(subscription_id)
+    requirements = summarize_subscription_network_requirements(line_items)
+    existing_connection = _load_subscription_connection(subscription_id)
+
+    return {
+        "subscription": subscription,
+        "line_items": line_items,
+        "network_provisioning": {
+            **requirements,
+            "existing_connection_id": existing_connection.get("id") if existing_connection else None,
+            "is_provisioned": bool(existing_connection),
+        },
+        "existing_connection": existing_connection,
+        "current_allocated_ranges": _load_connection_ranges(int(existing_connection["id"])) if existing_connection else [],
+        "shared_heads": _load_shared_heads_for_provisioning(requirements.get("required_ip_prefixes") or []),
+    }
+
+
+@router.post("/internet-connections/subscriptions/{subscription_id}/provision")
+async def provision_subscription_connection(subscription_id: int, payload: SubscriptionProvisionPayload):
+    subscription = _load_subscription(subscription_id)
+    line_items = _load_subscription_line_items(subscription_id)
+    requirements = summarize_subscription_network_requirements(line_items)
+    if not requirements["requires_provisioning"]:
+        raise HTTPException(status_code=400, detail="Subscription does not require network provisioning")
+
+    line_item_map = {int(item["id"]): item for item in line_items if item.get("id") is not None}
+
+    internet_item = None
+    if payload.internet_item_id is not None:
+        internet_item = line_item_map.get(int(payload.internet_item_id))
+        if not internet_item:
+            raise HTTPException(status_code=400, detail="Selected internet product is not part of the subscription")
+        internet_profile = build_network_product_profile(internet_item, fallback_text=internet_item.get("description"))
+        if internet_profile.get("kind") != "internet_access":
+            raise HTTPException(status_code=400, detail="Selected internet product is not an internet access line")
+    elif requirements.get("primary_internet_item"):
+        internet_item = line_item_map.get(int(requirements["primary_internet_item"]["subscription_item_id"]))
+        internet_profile = build_network_product_profile(internet_item, fallback_text=internet_item.get("description"))
+    else:
+        internet_profile = {}
+
+    requested_ip_items = requirements.get("ip_items") or []
+    requested_ip_item_ids = {int(item["subscription_item_id"]) for item in requested_ip_items if item.get("subscription_item_id") is not None}
+    provided_ip_item_ids = {int(item.subscription_item_id) for item in payload.ip_allocations}
+    if requested_ip_item_ids != provided_ip_item_ids:
+        raise HTTPException(status_code=409, detail="Du skal vaelge et ledigt IP-range til hver IP-produktlinje")
+
+    shared_connection = execute_query_single(
+        _connection_select_sql(" AND ic.id = %s AND ic.allocation_model = 'shared' AND ic.parent_id IS NULL "),
+        (payload.shared_connection_id,),
+    )
+    if not shared_connection:
+        raise HTTPException(status_code=404, detail="Shared head connection not found")
+
+    shared_connection = _decorate_connection_row(dict(shared_connection))
+    if not shared_connection.get("address"):
+        raise HTTPException(status_code=409, detail="Den valgte hovedforbindelse mangler adresse og kan ikke bruges")
+
+    existing_connection = _load_subscription_connection(subscription_id)
+
+    conn = get_db_connection()
+    try:
+        with conn.cursor(cursor_factory=RealDictCursor) as cursor:
+            cursor.execute(
+                """
+                SELECT *
+                FROM internet_connections_connections
+                WHERE id = %s
+                  AND deleted_at IS NULL
+                FOR UPDATE
+                """,
+                (payload.shared_connection_id,),
+            )
+            locked_shared_connection = cursor.fetchone()
+            if not locked_shared_connection:
+                raise HTTPException(status_code=404, detail="Shared head connection not found")
+
+            existing_row = None
+            existing_connection_id = None
+            previous_parent_id = payload.shared_connection_id
+            if existing_connection:
+                existing_connection_id = int(existing_connection["id"])
+                cursor.execute(
+                    """
+                    SELECT *
+                    FROM internet_connections_connections
+                    WHERE id = %s
+                      AND deleted_at IS NULL
+                    FOR UPDATE
+                    """,
+                    (existing_connection_id,),
+                )
+                existing_row = cursor.fetchone()
+                previous_parent_id = int(existing_row.get("parent_id") or payload.shared_connection_id)
+
+            selected_range_ids = [int(item.range_id) for item in payload.ip_allocations]
+            allocation_by_item = {
+                int(item.subscription_item_id): {
+                    "range_id": int(item.range_id),
+                    "requested_cidr": str(item.requested_cidr or "").strip() or None,
+                }
+                for item in payload.ip_allocations
+            }
+
+            for ip_item in requested_ip_items:
+                item_id = int(ip_item["subscription_item_id"])
+                allocation = allocation_by_item[item_id]
+                range_id = int(allocation["range_id"])
+                cursor.execute(
+                    """
+                    SELECT
+                        ir.*
+                    FROM internet_connections_ip_ranges ir
+                    WHERE ir.id = %s
+                      AND ir.connection_id = %s
+                      AND ir.deleted_at IS NULL
+                    FOR UPDATE
+                    """,
+                    (range_id, payload.shared_connection_id),
+                )
+                range_row = cursor.fetchone()
+                if not range_row:
+                    raise HTTPException(status_code=409, detail=f"IP-range #{range_id} er ikke ledigt paa den valgte hovedforbindelse")
+                cursor.execute(
+                    """
+                    SELECT
+                        COUNT(*) FILTER (WHERE deleted_at IS NULL) AS total_addresses,
+                        COUNT(*) FILTER (WHERE deleted_at IS NULL AND status = 'available') AS available_addresses
+                    FROM internet_connections_ip_addresses
+                    WHERE range_id = %s
+                    """,
+                    (range_id,),
+                )
+                range_stats = cursor.fetchone() or {}
+                prefix_length = _build_ip_range_payload(dict(range_row)).get("prefix_length")
+                expected_prefix = ip_item.get("ip_prefix_length")
+                requested_cidr = allocation.get("requested_cidr") or str(range_row.get("cidr") or "")
+                requested_network = _validate_cidr(requested_cidr)
+                source_network = _validate_cidr(str(range_row.get("cidr") or ""))
+                total_addresses = int(range_stats.get("total_addresses") or 0)
+                available_addresses = int(range_stats.get("available_addresses") or 0)
+                if total_addresses <= 0:
+                    raise HTTPException(status_code=409, detail=f"IP-range {range_row.get('cidr')} har ingen adresser")
+                if not requested_network.subnet_of(source_network):
+                    raise HTTPException(status_code=409, detail=f"IP-range {requested_cidr} ligger ikke i {range_row.get('cidr')}")
+                if expected_prefix is not None and int(requested_network.prefixlen) != int(expected_prefix):
+                    raise HTTPException(status_code=409, detail=f"IP-range {requested_cidr} matcher ikke /{expected_prefix}")
+                if prefix_length is not None and int(requested_network.prefixlen) < int(prefix_length):
+                    raise HTTPException(status_code=409, detail=f"IP-range {requested_cidr} er stoerre end kildeblokken {range_row.get('cidr')}")
+                if requested_cidr == str(range_row.get("cidr") or ""):
+                    if available_addresses != total_addresses:
+                        raise HTTPException(status_code=409, detail=f"IP-range {range_row.get('cidr')} er ikke laengere ledigt")
+                    if range_row.get("customer_id") is not None:
+                        raise HTTPException(status_code=409, detail=f"IP-range {range_row.get('cidr')} er allerede bundet til en anden kunde")
+
+            current_range_rows: List[Dict[str, Any]] = []
+            if existing_connection_id:
+                cursor.execute(
+                    """
+                    SELECT id
+                    FROM internet_connections_ip_ranges
+                    WHERE connection_id = %s
+                      AND deleted_at IS NULL
+                    FOR UPDATE
+                    """,
+                    (existing_connection_id,),
+                )
+                current_range_rows = [dict(row) for row in cursor.fetchall() or []]
+
+            connection_name = internet_item.get("description") if internet_item else subscription.get("product_name")
+            connection_name = str(connection_name or subscription.get("subscription_number") or "Internetforbindelse").strip()
+            sales_price = 0.0
+            if internet_item:
+                sales_price += float(internet_item.get("line_total") or 0)
+            for ip_item in requested_ip_items:
+                sales_price += float(ip_item.get("line_total") or 0)
+
+            connection_fields = (
+                connection_name,
+                locked_shared_connection.get("provider"),
+                subscription.get("customer_id"),
+                payload.shared_connection_id,
+                locked_shared_connection.get("address"),
+                "active",
+                sales_price,
+                locked_shared_connection.get("technology"),
+                internet_profile.get("connection_type") or locked_shared_connection.get("connection_type"),
+                internet_profile.get("speed_mbps"),
+                internet_profile.get("upload_mbps"),
+                internet_profile.get("download_mbps"),
+                "dedicated",
+                "subscription",
+                None,
+                subscription_id,
+            )
+
+            if existing_row:
+                cursor.execute(
+                    """
+                    UPDATE internet_connections_connections
+                    SET name = %s,
+                        provider = %s,
+                        customer_id = %s,
+                        parent_id = %s,
+                        address = %s,
+                        status = %s,
+                        sales_price = %s,
+                        technology = %s,
+                        connection_type = %s,
+                        speed_mbps = %s,
+                        upload_mbps = %s,
+                        download_mbps = %s,
+                        allocation_model = %s,
+                        value_type = %s,
+                        value_label = %s,
+                        subscription_id = %s,
+                        updated_at = CURRENT_TIMESTAMP
+                    WHERE id = %s
+                    RETURNING *
+                    """,
+                    connection_fields + (existing_connection_id,),
+                )
+                connection_row = cursor.fetchone()
+            else:
+                cursor.execute(
+                    """
+                    INSERT INTO internet_connections_connections (
+                        name, provider, customer_id, parent_id, address, status, sales_price, technology,
+                        connection_type, speed_mbps, upload_mbps, download_mbps,
+                        allocation_model, value_type, value_label, subscription_id
+                    ) VALUES (
+                        %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
+                    )
+                    RETURNING *
+                    """,
+                    connection_fields,
+                )
+                connection_row = cursor.fetchone()
+                existing_connection_id = int(connection_row["id"])
+
+            released_range_ids: List[int] = []
+            for current_range in current_range_rows:
+                current_range_id = int(current_range["id"])
+                if current_range_id in selected_range_ids:
+                    continue
+                cursor.execute(
+                    """
+                    UPDATE internet_connections_ip_ranges
+                    SET connection_id = %s,
+                        customer_id = NULL,
+                        service_address = NULL,
+                        updated_at = CURRENT_TIMESTAMP
+                    WHERE id = %s
+                    """,
+                    (previous_parent_id, current_range_id),
+                )
+                cursor.execute(
+                    """
+                    UPDATE internet_connections_ip_addresses
+                    SET status = 'available',
+                        assigned_to = NULL,
+                        assigned_type = NULL,
+                        assigned_customer_id = NULL,
+                        assigned_connection_id = NULL,
+                        comment = NULL,
+                        updated_at = CURRENT_TIMESTAMP
+                    WHERE range_id = %s
+                      AND deleted_at IS NULL
+                    """,
+                    (current_range_id,),
+                )
+                released_range_ids.append(current_range_id)
+
+            allocated_ranges: List[Dict[str, Any]] = []
+            for ip_item in requested_ip_items:
+                item_id = int(ip_item["subscription_item_id"])
+                allocation = allocation_by_item[item_id]
+                range_id = int(allocation["range_id"])
+                requested_cidr = allocation.get("requested_cidr")
+                cursor.execute(
+                    """
+                    SELECT *
+                    FROM internet_connections_ip_ranges
+                    WHERE id = %s
+                      AND deleted_at IS NULL
+                    FOR UPDATE
+                    """,
+                    (range_id,),
+                )
+                source_range = cursor.fetchone()
+                if not source_range:
+                    raise HTTPException(status_code=404, detail=f"IP-range #{range_id} blev ikke fundet")
+
+                source_cidr = str(source_range.get("cidr") or "")
+                effective_cidr = requested_cidr or source_cidr
+                if effective_cidr == source_cidr:
+                    cursor.execute(
+                        """
+                        UPDATE internet_connections_ip_ranges
+                        SET connection_id = %s,
+                            customer_id = %s,
+                            service_address = %s,
+                            updated_at = CURRENT_TIMESTAMP
+                        WHERE id = %s
+                        RETURNING *
+                        """,
+                        (existing_connection_id, subscription.get("customer_id"), locked_shared_connection.get("address"), range_id),
+                    )
+                    allocated_range = cursor.fetchone()
+                    cursor.execute(
+                        """
+                        UPDATE internet_connections_ip_addresses
+                        SET status = 'reserved',
+                            assigned_to = %s,
+                            assigned_type = 'subscription',
+                            assigned_customer_id = %s,
+                            assigned_connection_id = %s,
+                            updated_at = CURRENT_TIMESTAMP
+                        WHERE range_id = %s
+                          AND deleted_at IS NULL
+                        """,
+                        (subscription.get("subscription_number"), subscription.get("customer_id"), existing_connection_id, range_id),
+                    )
+                else:
+                    requested_network = _validate_cidr(effective_cidr)
+                    host_addresses = [str(host) for host in requested_network.hosts()]
+                    if not host_addresses:
+                        raise HTTPException(status_code=409, detail=f"IP-range {effective_cidr} har ingen brugbare adresser")
+                    cursor.execute(
+                        """
+                        SELECT id, ip_address, status
+                        FROM internet_connections_ip_addresses
+                        WHERE range_id = %s
+                          AND deleted_at IS NULL
+                        FOR UPDATE
+                        """,
+                        (range_id,),
+                    )
+                    source_addresses = cursor.fetchall() or []
+                    source_address_map = {str(row.get("ip_address")): dict(row) for row in source_addresses}
+                    missing_addresses = [ip for ip in host_addresses if ip not in source_address_map]
+                    if missing_addresses:
+                        raise HTTPException(status_code=409, detail=f"IP-range {effective_cidr} mangler adresser i lageret")
+                    busy_addresses = [
+                        ip for ip in host_addresses
+                        if str(source_address_map[ip].get("status") or "available").lower() != "available"
+                    ]
+                    if busy_addresses:
+                        raise HTTPException(status_code=409, detail=f"IP-range {effective_cidr} er ikke laengere ledigt")
+                    cursor.execute(
+                        """
+                        INSERT INTO internet_connections_ip_ranges (
+                            connection_id, name, cidr, description, provider_reference,
+                            contract_number, customer_id, service_address, monthly_cost, sales_price
+                        )
+                        VALUES (%s, %s, %s, %s, %s, %s, %s, %s, 0, 0)
+                        RETURNING *
+                        """,
+                        (
+                            existing_connection_id,
+                            f"{source_range.get('name') or 'IP-range'} -> {effective_cidr}",
+                            effective_cidr,
+                            source_range.get("description"),
+                            source_range.get("provider_reference"),
+                            source_range.get("contract_number"),
+                            subscription.get("customer_id"),
+                            locked_shared_connection.get("address"),
+                        ),
+                    )
+                    allocated_range = cursor.fetchone()
+                    allocated_range_id = int(allocated_range["id"])
+                    cursor.execute(
+                        """
+                        UPDATE internet_connections_ip_addresses
+                        SET range_id = %s,
+                            status = 'reserved',
+                            assigned_to = %s,
+                            assigned_type = 'subscription',
+                            assigned_customer_id = %s,
+                            assigned_connection_id = %s,
+                            updated_at = CURRENT_TIMESTAMP
+                        WHERE id = ANY(%s)
+                        """,
+                        (
+                            allocated_range_id,
+                            subscription.get("subscription_number"),
+                            subscription.get("customer_id"),
+                            existing_connection_id,
+                            [int(source_address_map[ip]["id"]) for ip in host_addresses],
+                        ),
+                    )
+                allocated_ranges.append(_build_ip_range_payload(dict(allocated_range)))
+
+            conn.commit()
+
+        _create_history_entry(
+            existing_connection_id,
+            "subscription_provisioned",
+            f"Provisionerede forbindelse fra abonnement {subscription.get('subscription_number')}",
+            {
+                "subscription_id": subscription_id,
+                "shared_connection_id": payload.shared_connection_id,
+                "internet_item_id": payload.internet_item_id,
+                "allocated_range_ids": selected_range_ids,
+                "released_range_ids": released_range_ids,
+            },
+        )
+        _create_history_entry(
+            payload.shared_connection_id,
+            "shared_capacity_allocated",
+            f"Allokerede kapacitet til abonnement {subscription.get('subscription_number')}",
+            {
+                "subscription_id": subscription_id,
+                "connection_id": existing_connection_id,
+                "allocated_range_ids": selected_range_ids,
+            },
+        )
+
+        return {
+            "subscription_id": subscription_id,
+            "connection": _load_subscription_connection(subscription_id),
+            "allocated_ranges": _load_connection_ranges(existing_connection_id),
+            "released_range_ids": released_range_ids,
+            "reused_existing_connection": bool(existing_connection),
+        }
+    finally:
+        release_db_connection(conn)
+
+
+@router.post("/internet-connections/{connection_id}/bmcnet-connections")
+async def create_quick_bmcnet_connection(connection_id: int, payload: QuickBmcnetCreatePayload):
+    head_row = execute_query_single(
+        _connection_select_sql(" AND ic.id = %s AND ic.allocation_model = 'shared' AND ic.parent_id IS NULL "),
+        (connection_id,),
+    )
+    if not head_row:
+        raise HTTPException(status_code=404, detail="Delt hovedforbindelse blev ikke fundet")
+
+    head = _decorate_connection_row(dict(head_row))
+    customer = execute_query_single(
+        """
+        SELECT id, name
+        FROM customers
+        WHERE id = %s
+        LIMIT 1
+        """,
+        (payload.customer_id,),
+    )
+    if not customer:
+        raise HTTPException(status_code=404, detail="Kunden blev ikke fundet")
+
+    address = str(payload.address or head.get("address") or "").strip()
+    if not address:
+        raise HTTPException(status_code=400, detail="Adresse er påkrævet for BMCnet-forbindelsen")
+
+    customer_name = str(customer.get("name") or "").strip() or f"Kunde #{payload.customer_id}"
+    service_label = str(payload.service_label or "").strip() or f"BMCnet - {customer_name}"
+    wizard_notes = str(payload.notes or "").strip() or None
+
+    product_ids = [int(payload.internet_product_id)]
+    if payload.ip_product_id:
+        product_ids.append(int(payload.ip_product_id))
+    product_rows = execute_query(
+        """
+        SELECT id, name, short_description, sales_price, attributes_json, type
+        FROM products
+        WHERE id = ANY(%s)
+          AND deleted_at IS NULL
+        """,
+        (product_ids,),
+    ) or []
+    product_map = {int(row["id"]): dict(row) for row in product_rows if row.get("id") is not None}
+
+    internet_product = product_map.get(int(payload.internet_product_id))
+    if not internet_product:
+        raise HTTPException(status_code=404, detail="Internetproduktet blev ikke fundet")
+    internet_profile = build_network_product_profile(internet_product, fallback_text=internet_product.get("short_description"))
+    if internet_profile.get("kind") != "internet_access":
+        raise HTTPException(status_code=400, detail="Det valgte internetprodukt er ikke et netværksprodukt")
+
+    ip_product = None
+    ip_profile = {}
+    selected_ip_address = None
+    if payload.ip_product_id:
+        ip_product = product_map.get(int(payload.ip_product_id))
+        if not ip_product:
+            raise HTTPException(status_code=404, detail="IP-produktet blev ikke fundet")
+        ip_profile = build_network_product_profile(ip_product, fallback_text=ip_product.get("short_description"))
+        if ip_profile.get("kind") != "ip_allocation":
+            raise HTTPException(status_code=400, detail="Det valgte IP-produkt er ikke et IP-allokeringsprodukt")
+        is_static_wan_ip = bool(
+            int(ip_profile.get("ip_prefix_length") or 0) == 32
+            or "statisk wan" in f"{ip_product.get('name') or ''} {ip_product.get('short_description') or ''}".lower()
+        )
+        if is_static_wan_ip:
+            if not payload.ip_address_id:
+                raise HTTPException(status_code=400, detail="Vælg en ledig IP-adresse til Statisk WAN IP")
+            selected_ip_address = execute_query_single(
+                """
+                SELECT
+                    ipa.id,
+                    ipa.ip_address,
+                    ipa.range_id,
+                    ipa.status,
+                    ir.connection_id,
+                    ir.service_address,
+                    ir.cidr,
+                    child.name AS connection_name,
+                    child.parent_id AS connection_parent_id
+                FROM internet_connections_ip_addresses ipa
+                JOIN internet_connections_ip_ranges ir ON ir.id = ipa.range_id
+                LEFT JOIN internet_connections_connections child ON child.id = ir.connection_id
+                WHERE ipa.id = %s
+                  AND ipa.deleted_at IS NULL
+                  AND ir.deleted_at IS NULL
+                LIMIT 1
+                """,
+                (payload.ip_address_id,),
+            )
+            if not selected_ip_address:
+                raise HTTPException(status_code=404, detail="Den valgte IP-adresse blev ikke fundet")
+            if int(selected_ip_address.get("connection_id") or 0) != int(connection_id):
+                if int(selected_ip_address.get("connection_parent_id") or 0) == int(connection_id):
+                    child_name = str(selected_ip_address.get("connection_name") or "").strip()
+                    child_label = child_name or f"Forbindelse #{selected_ip_address.get('connection_id')}"
+                    raise HTTPException(
+                        status_code=409,
+                        detail=f"Den valgte IP-adresse er allerede reserveret på {child_label}. Opdater siden før du opretter igen.",
+                    )
+                raise HTTPException(status_code=409, detail="Den valgte IP-adresse ligger ikke på den valgte hovedforbindelse")
+            if str(selected_ip_address.get("status") or "").lower() != "available":
+                raise HTTPException(status_code=409, detail="Den valgte IP-adresse er ikke længere ledig")
+        elif not payload.range_id:
+            raise HTTPException(status_code=400, detail="Vælg et IP-range til IP-produktet")
+    elif payload.range_id or payload.ip_address_id:
+        raise HTTPException(status_code=400, detail="Der er valgt IP-allokering uden et IP-produkt")
+
+    case_title = str(payload.case_title or "").strip() or f"BMCnet - {customer_name}"
+    description_lines = [
+        f"Hovedforbindelse: {head.get('name') or connection_id}",
+        f"Service: {service_label}",
+        f"Adresse: {address}",
+        f"Internetprodukt: {internet_product.get('name') or '-'}",
+    ]
+    if ip_product:
+        description_lines.append(f"IP-produkt: {ip_product.get('name') or '-'}")
+    if wizard_notes:
+        description_lines.append("")
+        description_lines.append(wizard_notes)
+
+    assigned_group_id = _resolve_group_id_by_name_tokens(["økonomi", "okonomi", "economy"])
+    created_case = execute_query_single(
+        """
+        INSERT INTO sag_sager (
+            titel, beskrivelse, template_key, status, customer_id, assigned_group_id, created_by_user_id
+        )
+        VALUES (%s, %s, %s, %s, %s, %s, %s)
+        RETURNING *
+        """,
+        (
+            case_title,
+            "\n".join(description_lines),
+            "abonnement",
+            "åben",
+            payload.customer_id,
+            assigned_group_id,
+            1,
+        ),
+    )
+    if not created_case or not created_case.get("id"):
+        raise HTTPException(status_code=500, detail="Kunne ikke oprette sag")
+
+    line_items = [{
+        "product_id": int(internet_product["id"]),
+        "description": str(internet_product.get("short_description") or internet_product.get("name") or "").strip(),
+        "quantity": 1,
+        "unit_price": float(payload.internet_unit_price if payload.internet_unit_price is not None else (internet_product.get("sales_price") or 0)),
+    }]
+    if ip_product:
+        line_items.append({
+            "product_id": int(ip_product["id"]),
+            "description": str(ip_product.get("short_description") or ip_product.get("name") or "").strip(),
+            "quantity": 1,
+            "unit_price": float(payload.ip_unit_price if payload.ip_unit_price is not None else (ip_product.get("sales_price") or 0)),
+        })
+
+    from app.subscriptions.backend.router import create_subscription as create_sag_subscription
+
+    subscription = await create_sag_subscription({
+        "sag_id": int(created_case["id"]),
+        "billing_interval": payload.billing_interval,
+        "billing_day": int(payload.billing_day),
+        "start_date": payload.start_date.isoformat(),
+        "notes": wizard_notes,
+        "line_items": line_items,
+    })
+    subscription_id = int(subscription["id"])
+    line_items_created = _load_subscription_line_items(subscription_id)
+    requirements = summarize_subscription_network_requirements(line_items_created)
+    internet_item = requirements.get("primary_internet_item")
+    if not internet_item:
+        raise HTTPException(status_code=500, detail="Abonnementet blev oprettet men internetlinjen kunne ikke findes")
+
+    ip_allocations: List[SubscriptionIpAllocationPayload] = []
+    if ip_product:
+        ip_item = next((item for item in requirements.get("ip_items") or [] if int(item.get("product_id") or 0) == int(ip_product["id"])), None)
+        if not ip_item:
+            raise HTTPException(status_code=500, detail="Abonnementet blev oprettet men IP-linjen kunne ikke findes")
+        requested_cidr = None
+        allocation_range_id = int(payload.range_id or 0)
+        if selected_ip_address:
+            allocation_range_id = int(selected_ip_address["range_id"])
+            requested_cidr = f"{selected_ip_address['ip_address']}/32"
+        elif payload.range_id:
+            range_row = execute_query_single(
+                "SELECT cidr FROM internet_connections_ip_ranges WHERE id = %s AND deleted_at IS NULL",
+                (payload.range_id,),
+            )
+            if range_row and range_row.get("cidr"):
+                requested_cidr = str(range_row.get("cidr"))
+        ip_allocations.append(SubscriptionIpAllocationPayload(
+            subscription_item_id=int(ip_item["subscription_item_id"]),
+            range_id=allocation_range_id,
+            requested_cidr=requested_cidr,
+        ))
+
+    provisioned = await provision_subscription_connection(
+        subscription_id,
+        SubscriptionProvisionPayload(
+            shared_connection_id=connection_id,
+            internet_item_id=int(internet_item["subscription_item_id"]),
+            ip_allocations=ip_allocations,
+        ),
+    )
+
+    connection = provisioned.get("connection") or _load_subscription_connection(subscription_id)
+    if connection:
+        execute_query(
+            """
+            UPDATE internet_connections_connections
+            SET name = %s,
+                address = %s,
+                notes = %s,
+                updated_at = CURRENT_TIMESTAMP
+            WHERE id = %s
+            """,
+            (
+                case_title,
+                address,
+                f"Service: {service_label}" if not wizard_notes else f"Service: {service_label}\n{wizard_notes}",
+                int(connection["id"]),
+            ),
+        )
+        if payload.range_id:
+            execute_query(
+                """
+                UPDATE internet_connections_ip_ranges
+                SET service_address = %s,
+                    updated_at = CURRENT_TIMESTAMP
+                WHERE connection_id = %s
+                  AND deleted_at IS NULL
+                """,
+                (address, int(connection["id"])),
+            )
+        if selected_ip_address and payload.mark_gateway:
+            execute_query(
+                """
+                UPDATE internet_connections_ip_addresses ipa
+                SET assigned_type = 'bmcnet_gateway',
+                    comment = %s,
+                    updated_at = CURRENT_TIMESTAMP
+                FROM internet_connections_ip_ranges ir
+                WHERE ipa.range_id = ir.id
+                  AND ir.connection_id = %s
+                  AND ipa.ip_address = %s
+                  AND ipa.deleted_at IS NULL
+                """,
+                ("BMCnet kunde gateway", int(connection["id"]), str(selected_ip_address["ip_address"])),
+            )
+        connection = _load_subscription_connection(subscription_id)
+
+    _create_history_entry(
+        int(connection["id"]),
+        "bmcnet_connection_created",
+        f"Oprettede BMCnet-forbindelse via wizard fra sag #{created_case['id']}",
+        {
+            "parent_connection_id": connection_id,
+            "customer_id": payload.customer_id,
+            "service_label": service_label,
+            "subscription_id": subscription_id,
+            "sag_id": int(created_case["id"]),
+        },
+    )
+    return {
+        "sag": created_case,
+        "subscription": subscription,
+        "connection": connection,
+        "allocated_range_id": int(payload.range_id) if payload.range_id else None,
+        "allocated_ip_address_id": int(selected_ip_address["id"]) if selected_ip_address else None,
+    }
+
+
+@router.get("/internet-connections/{connection_id}/ip-ranges")
+async def list_ip_ranges(connection_id: int):
+    try:
+        connection_rows = execute_query(
+            _connection_select_sql(" AND ic.id = %s "),
+            (connection_id,),
+        ) or []
+        connection = _decorate_connection_row(dict(connection_rows[0])) if connection_rows else None
+        range_rows = execute_query(
+            """
+            SELECT
+                ir.*,
+                c.name AS customer_name
+            FROM internet_connections_ip_ranges ir
+            LEFT JOIN customers c ON c.id = ir.customer_id
+            WHERE ir.connection_id = %s AND ir.deleted_at IS NULL
+            ORDER BY id ASC
+            """,
+            (connection_id,),
+        ) or []
+        address_rows = execute_query(
+            """
+            SELECT ipa.id, ipa.range_id, ipa.ip_address, ipa.status
+            FROM internet_connections_ip_addresses ipa
+            JOIN internet_connections_ip_ranges ir ON ir.id = ipa.range_id
+            WHERE ir.connection_id = %s AND ipa.deleted_at IS NULL
+            ORDER BY ipa.ip_address ASC
+            """,
+            (connection_id,),
+        ) or []
+    except Exception as exc:
+        logger.warning("Failed to load IP ranges: %s", exc)
+        return []
+
+    address_map: dict[int, list[dict]] = {}
+    for address in address_rows:
+        address_map.setdefault(int(address.get("range_id")), []).append(address)
+
+    payload = []
+    for row in range_rows:
+        item = _build_ip_range_payload(dict(row), address_map.get(int(row.get("id")), []))
+        if connection:
+            item.update(_range_alignment_for_connection(connection, item))
+        payload.append(item)
+    return payload
+
+
+@router.post("/internet-connections/{connection_id}/ip-ranges")
+async def create_ip_range(connection_id: int, payload: IpRangeCreatePayload):
+    cidr = payload.cidr
+    if not cidr:
+        raise HTTPException(status_code=400, detail="CIDR is required")
+    network = _validate_cidr(str(cidr))
+
+    duplicate_range = execute_query(
+        """
+        SELECT ir.id, ir.connection_id, ir.cidr, ic.name AS connection_name
+        FROM internet_connections_ip_ranges ir
+        LEFT JOIN internet_connections_connections ic ON ic.id = ir.connection_id
+        WHERE ir.cidr = %s
+          AND ir.deleted_at IS NULL
+        LIMIT 1
+        """,
+        (str(network),),
+    ) or []
+    if duplicate_range:
+        row = duplicate_range[0]
+        raise HTTPException(
+            status_code=409,
+            detail=f"IP-range {row.get('cidr')} findes allerede på forbindelse {row.get('connection_name') or row.get('connection_id')}",
+        )
+
+    host_ips = [str(host) for host in network.hosts()]
+    if host_ips:
+        conflicting_rows = execute_query(
+            """
+            SELECT
+                ipa.ip_address,
+                ir.cidr,
+                ic.id AS connection_id,
+                ic.name AS connection_name
+            FROM internet_connections_ip_addresses ipa
+            JOIN internet_connections_ip_ranges ir ON ir.id = ipa.range_id
+            LEFT JOIN internet_connections_connections ic ON ic.id = ir.connection_id
+            WHERE ipa.deleted_at IS NULL
+              AND ipa.ip_address = ANY(%s)
+            ORDER BY ipa.ip_address ASC
+            LIMIT 5
+            """,
+            (host_ips,),
+        ) or []
+        if conflicting_rows:
+            examples = ", ".join(
+                f"{row.get('ip_address')} ({row.get('connection_name') or row.get('connection_id')} / {row.get('cidr')})"
+                for row in conflicting_rows
+            )
+            raise HTTPException(
+                status_code=409,
+                detail=f"IP-range {network} overlapper eksisterende IP-adresser: {examples}",
+            )
+
+    try:
+        rows = execute_query(
+            """
+            INSERT INTO internet_connections_ip_ranges (
+                connection_id, name, cidr, description, provider_reference,
+                contract_number, customer_id, service_address, monthly_cost, sales_price
+            )
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+            RETURNING *
+            """,
+            (
+                connection_id,
+                payload.name,
+                str(network),
+                payload.description,
+                payload.provider_reference,
+                payload.contract_number,
+                payload.customer_id,
+                payload.service_address,
+                payload.monthly_cost,
+                payload.sales_price,
+            ),
+        ) or []
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.exception("Failed to create IP range on connection %s", connection_id)
+        raise HTTPException(status_code=500, detail=f"Kunne ikke oprette IP-range: {exc}") from exc
+    if not rows:
+        raise HTTPException(status_code=500, detail="Failed to create IP range")
+
+    range_row = dict(rows[0])
+    try:
+        _create_ip_addresses_for_range(int(range_row["id"]), str(network))
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.exception("Failed to auto-create IP addresses for range %s", range_row.get("id"))
+        execute_query(
+            """
+            UPDATE internet_connections_ip_ranges
+            SET deleted_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
+            WHERE id = %s
+            """,
+            (range_row["id"],),
+        )
+        raise HTTPException(status_code=500, detail=f"IP-range blev oprettet men IP-adresser kunne ikke genereres: {exc}") from exc
+
+    _create_history_entry(
+        connection_id,
+        "ip_range_created",
+        f"Oprettede IP-range {payload.name}",
+        {
+            "range_name": payload.name,
+            "cidr": payload.cidr,
+            "provider_reference": payload.provider_reference,
+            "contract_number": payload.contract_number,
+            "customer_id": payload.customer_id,
+        },
+    )
+    return range_row
+
+
+@router.put("/internet-connections/{connection_id}/ip-ranges/{range_id}")
+async def update_ip_range(connection_id: int, range_id: int, payload: IpRangeUpdatePayload):
+    existing_rows = execute_query(
+        """
+        SELECT *
+        FROM internet_connections_ip_ranges
+        WHERE id = %s AND connection_id = %s AND deleted_at IS NULL
+        LIMIT 1
+        """,
+        (range_id, connection_id),
+    ) or []
+    if not existing_rows:
+        raise HTTPException(status_code=404, detail="IP-range not found")
+
+    existing = dict(existing_rows[0])
+    update_values = payload.model_dump(exclude_unset=True)
+    if not update_values:
+        return _build_ip_range_payload(existing)
+
+    merged = dict(existing)
+    merged.update(update_values)
+    merged["name"] = str(merged.get("name") or "").strip() or str(existing.get("cidr") or "")
+    merged["description"] = str(merged.get("description") or "").strip() or None
+    merged["provider_reference"] = str(merged.get("provider_reference") or "").strip() or None
+    merged["contract_number"] = str(merged.get("contract_number") or "").strip() or None
+    merged["service_address"] = str(merged.get("service_address") or "").strip() or None
+
+    if not merged["name"]:
+        raise HTTPException(status_code=400, detail="Navn er påkrævet")
+
+    changed = {}
+    fields = [
+        "name",
+        "description",
+        "provider_reference",
+        "contract_number",
+        "customer_id",
+        "service_address",
+        "monthly_cost",
+        "sales_price",
+    ]
+    params: list[object] = []
+    set_parts: list[str] = []
+    for field in fields:
+        value = merged.get(field)
+        set_parts.append(f"{field} = %s")
+        params.append(value)
+        if existing.get(field) != value:
+            changed[field] = value
+
+    try:
+        rows = execute_query(
+            f"""
+            UPDATE internet_connections_ip_ranges
+            SET {", ".join(set_parts)}, updated_at = CURRENT_TIMESTAMP
+            WHERE id = %s AND connection_id = %s AND deleted_at IS NULL
+            RETURNING *
+            """,
+            tuple(params + [range_id, connection_id]),
+        ) or []
+    except Exception as exc:
+        logger.exception("Failed to update IP range %s on connection %s", range_id, connection_id)
+        raise HTTPException(status_code=500, detail=f"Kunne ikke gemme IP-range: {exc}") from exc
+
+    if not rows:
+        raise HTTPException(status_code=500, detail="Failed to update IP range")
+
+    if changed:
+        _create_history_entry(
+            connection_id,
+            "ip_range_updated",
+            f"Opdaterede IP-range {rows[0].get('name') or rows[0].get('cidr')}",
+            {
+                "range_id": range_id,
+                "cidr": rows[0].get("cidr"),
+                "changes": changed,
+            },
+        )
+
+    address_rows = execute_query(
+        """
+        SELECT *
+        FROM internet_connections_ip_addresses
+        WHERE range_id = %s AND deleted_at IS NULL
+        ORDER BY ip_address ASC
+        """,
+        (range_id,),
+    ) or []
+    return _build_ip_range_payload(dict(rows[0]), [dict(row) for row in address_rows])
+
+
+@router.get("/internet-connections/{connection_id}/ip-addresses")
+async def list_ip_addresses(connection_id: int):
+    connection_rows = execute_query(
+        _connection_select_sql(" AND ic.id = %s "),
+        (connection_id,),
+    ) or []
+    connection = _decorate_connection_row(dict(connection_rows[0])) if connection_rows else None
+
+    where_sql = "ir.connection_id = %s"
+    params: tuple[object, ...]
+    if connection and connection.get("is_shared_head"):
+        where_sql = """
+            (
+                ir.connection_id = %s
+                OR ir.connection_id IN (
+                    SELECT child.id
+                    FROM internet_connections_connections child
+                    WHERE child.parent_id = %s
+                      AND child.deleted_at IS NULL
+                )
+            )
+        """
+        params = (connection_id, connection_id)
+    else:
+        params = (connection_id,)
+
+    rows = execute_query(
+        f"""
+        SELECT
+            ipa.*,
+            ir.name AS range_name,
+            ir.cidr AS range_cidr,
+            ir.connection_id AS range_connection_id,
+            ir.service_address AS range_service_address,
+            ir.customer_id AS range_customer_id,
+            rc.name AS range_customer_name,
+            c.name AS assigned_customer_name,
+            ic.name AS assigned_connection_name,
+            owner.name AS range_connection_name,
+            sub.id AS assigned_subscription_id,
+            sub.subscription_number AS assigned_subscription_number,
+            sub.sag_id AS assigned_subscription_sag_id
+        FROM internet_connections_ip_addresses ipa
+        JOIN internet_connections_ip_ranges ir ON ir.id = ipa.range_id
+        LEFT JOIN customers rc ON rc.id = ir.customer_id
+        LEFT JOIN customers c ON c.id = ipa.assigned_customer_id
+        LEFT JOIN internet_connections_connections ic ON ic.id = ipa.assigned_connection_id
+        LEFT JOIN internet_connections_connections owner ON owner.id = ir.connection_id
+        LEFT JOIN sag_subscriptions sub ON sub.id = ic.subscription_id
+        WHERE {where_sql} AND ipa.deleted_at IS NULL
+        ORDER BY ipa.ip_address ASC
+        """,
+        params,
+    ) or []
+    payload = []
+    for row in rows:
+        item = dict(row)
+        if connection:
+            item.update(
+                _range_alignment_for_connection(
+                    connection,
+                    {
+                        "service_address": item.get("range_service_address"),
+                        "customer_id": item.get("range_customer_id"),
+                        "customer_name": item.get("range_customer_name"),
+                    },
+                )
+            )
+        status = str(item.get("status", "available")).lower()
+        if status == "in_use":
+            item["status_label"] = "I brug"
+            item["badge_class"] = "bg-primary"
+        elif status == "reserved":
+            item["status_label"] = "Reserveret"
+            item["badge_class"] = "bg-warning"
+        else:
+            item["status_label"] = "Tilgængelig"
+            item["badge_class"] = "bg-success"
+        payload.append(item)
+    return payload
+
+
+@router.get("/internet-connections/{connection_id}/ip-addresses/summary")
+async def summarize_ip_addresses(connection_id: int):
+    connection_rows = execute_query(
+        _connection_select_sql(" AND ic.id = %s "),
+        (connection_id,),
+    ) or []
+    connection = _decorate_connection_row(dict(connection_rows[0])) if connection_rows else None
+
+    where_sql = "ir.connection_id = %s"
+    params: tuple[object, ...]
+    if connection and connection.get("is_shared_head"):
+        where_sql = """
+            (
+                ir.connection_id = %s
+                OR ir.connection_id IN (
+                    SELECT child.id
+                    FROM internet_connections_connections child
+                    WHERE child.parent_id = %s
+                      AND child.deleted_at IS NULL
+                )
+            )
+        """
+        params = (connection_id, connection_id)
+    else:
+        params = (connection_id,)
+
+    rows = execute_query(
+        f"""
+        SELECT
+            COUNT(*) FILTER (WHERE status = 'available') AS available,
+            COUNT(*) FILTER (WHERE status = 'in_use') AS in_use,
+            COUNT(*) FILTER (WHERE status = 'reserved') AS reserved
+        FROM internet_connections_ip_addresses ipa
+        JOIN internet_connections_ip_ranges ir ON ir.id = ipa.range_id
+        WHERE {where_sql} AND ipa.deleted_at IS NULL
+        """,
+        params,
+    ) or []
+    if not rows:
+        return {"available": 0, "in_use": 0, "reserved": 0}
+    return dict(rows[0])
+
+
+@router.post("/internet-connections/{connection_id}/ip-addresses")
+async def create_ip_address(connection_id: int, payload: IpAddressCreatePayload):
+    normalized_ip = _normalize_ip_address(payload.ip_address)
+    duplicate = execute_query(
+        """
+        SELECT id, range_id
+        FROM internet_connections_ip_addresses
+        WHERE ip_address = %s
+          AND deleted_at IS NULL
+        LIMIT 1
+        """,
+        (normalized_ip,),
+    ) or []
+    if duplicate:
+        raise HTTPException(status_code=409, detail=f"IP-adressen {normalized_ip} findes allerede")
+
+    rows = execute_query(
+        """
+        INSERT INTO internet_connections_ip_addresses (
+            range_id, ip_address, status, assigned_to, assigned_type,
+            assigned_customer_id, assigned_connection_id, comment
+        )
+        SELECT ir.id, %s, %s, %s, %s, %s, %s, %s
+        FROM internet_connections_ip_ranges ir
+        WHERE ir.connection_id = %s AND ir.id = %s AND ir.deleted_at IS NULL
+        RETURNING *
+        """,
+        (
+            normalized_ip,
+            payload.status,
+            payload.assigned_to,
+            payload.assigned_type,
+            payload.assigned_customer_id,
+            payload.assigned_connection_id,
+            payload.comment,
+            connection_id,
+            payload.range_id,
+        ),
+    ) or []
+    if not rows:
+        raise HTTPException(status_code=404, detail="No IP range available for this connection")
+
+    _create_history_entry(
+        connection_id,
+        "ip_address_created",
+        f"Oprettede IP-adresse {normalized_ip}",
+        {
+            "ip_address": normalized_ip,
+            "status": payload.status,
+            "assigned_customer_id": payload.assigned_customer_id,
+            "assigned_connection_id": payload.assigned_connection_id,
+        },
+    )
+    return dict(rows[0])
+
+
+@router.put("/internet-connections/{connection_id}/ip-addresses/{address_id}")
+async def update_ip_address(connection_id: int, address_id: int, payload: IpAddressUpdatePayload):
+    rows = execute_query(
+        """
+        UPDATE internet_connections_ip_addresses ipa
+        SET status = %s,
+            assigned_to = %s,
+            assigned_type = %s,
+            assigned_customer_id = %s,
+            assigned_connection_id = %s,
+            comment = %s,
+            updated_at = CURRENT_TIMESTAMP
+        FROM internet_connections_ip_ranges ir
+        WHERE ipa.range_id = ir.id
+          AND ir.connection_id = %s
+          AND ipa.id = %s
+          AND ipa.deleted_at IS NULL
+        RETURNING ipa.*
+        """,
+        (
+            payload.status,
+            payload.assigned_to,
+            payload.assigned_type,
+            payload.assigned_customer_id,
+            payload.assigned_connection_id,
+            payload.comment,
+            connection_id,
+            address_id,
+        ),
+    ) or []
+    if not rows:
+        raise HTTPException(status_code=404, detail="IP address not found")
+
+    item = dict(rows[0])
+    _create_history_entry(
+        connection_id,
+        "ip_address_updated",
+        f"Opdaterede IP-adresse {item.get('ip_address')}",
+        {
+            "ip_address": item.get("ip_address"),
+            "status": item.get("status"),
+            "assigned_customer_id": item.get("assigned_customer_id"),
+            "assigned_connection_id": item.get("assigned_connection_id"),
+        },
+    )
+    return item
+
+
+@router.post("/internet-connections/{connection_id}/pricing", response_model=dict)
+async def create_connection_pricing(connection_id: int, payload: PricingCreatePayload):
+    rows = execute_query(
+        """
+        INSERT INTO internet_connections_pricing (
+            connection_id, effective_from, purchase_price, sales_price, notes
+        )
+        VALUES (%s, %s, %s, %s, %s)
+        RETURNING *
+        """,
+        (connection_id, payload.effective_from, payload.purchase_price, payload.sales_price, payload.notes),
+    ) or []
+    if not rows:
+        raise HTTPException(status_code=500, detail="Failed to create pricing entry")
+
+    execute_query(
+        """
+        UPDATE internet_connections_connections
+        SET monthly_cost = %s, sales_price = %s, updated_at = CURRENT_TIMESTAMP
+        WHERE id = %s AND deleted_at IS NULL
+        """,
+        (payload.purchase_price, payload.sales_price, connection_id),
+    )
+
+    _create_history_entry(
+        connection_id,
+        "pricing_updated",
+        f"Opdaterede pris til {payload.sales_price} kr.",
+        {"effective_from": payload.effective_from.isoformat(), "purchase_price": payload.purchase_price, "sales_price": payload.sales_price},
+    )
+    return dict(rows[0])
+
+
+@router.get("/internet-connections/{connection_id}/pricing")
+async def get_connection_pricing(connection_id: int):
+    rows = execute_query(
+        """
+        SELECT
+            monthly_cost,
+            sales_price,
+            connection_type,
+            speed_mbps,
+            upload_mbps,
+            download_mbps,
+            contract_start,
+            contract_end,
+            status
+        FROM internet_connections_connections
+        WHERE id = %s AND deleted_at IS NULL
+        """,
+        (connection_id,),
+    ) or []
+    if not rows:
+        raise HTTPException(status_code=404, detail="Connection not found")
+
+    payload = dict(rows[0])
+    payload["contract_status"] = _get_contract_status(payload.get("contract_end"))
+    return payload
+
+
+@router.get("/internet-connections/{connection_id}/pricing/history")
+async def list_pricing_history(connection_id: int):
+    rows = execute_query(
+        """
+        SELECT *
+        FROM internet_connections_pricing
+        WHERE connection_id = %s
+        ORDER BY effective_from DESC, created_at DESC
+        """,
+        (connection_id,),
+    ) or []
+    return [dict(row) for row in rows]
+
+
+@router.get("/internet-connections/{connection_id}/history")
+async def list_history(connection_id: int):
+    rows = execute_query(
+        """
+        SELECT *
+        FROM internet_connections_history
+        WHERE connection_id = %s
+        ORDER BY created_at DESC
+        """,
+        (connection_id,),
+    ) or []
+    return [dict(row) for row in rows]
+
+
+@router.get("/internet-connections/customer-documents")
+async def list_customer_documents(customer_id: Optional[int] = Query(None, ge=1)):
+    if customer_id:
+        customer = execute_query_single(
+            "SELECT id, name FROM customers WHERE id = %s AND is_active = true",
+            (customer_id,),
+        )
+        if not customer:
+            raise HTTPException(status_code=404, detail="Customer not found")
+        payload = await _build_customer_document_hits(int(customer["id"]), str(customer["name"] or ""), None)
+        return {
+            "customer": {"id": int(customer["id"]), "name": customer["name"]},
+            "documents": payload["documents"],
+            "segments": payload["segments"],
+        }
+
+    rows = execute_query(
+        """
+        SELECT id, customer_id, original_filename, file_size, mime_type, notes, created_at, extracted_text
+        FROM internet_connections_customer_documents
+        WHERE deleted_at IS NULL
+        ORDER BY created_at DESC, id DESC
+        LIMIT 100
+        """
+    ) or []
+    documents = []
+    for row in rows:
+        item = dict(row)
+        item["segment_count"] = _ensure_document_segments(int(item["id"]), item.get("extracted_text"))
+        item.pop("extracted_text", None)
+        documents.append(item)
+    return {"documents": documents, "customer": None}
+
+
+@router.post("/internet-connections/customer-documents/upload")
+async def upload_customer_document(
+    customer_id: Optional[int] = Form(None),
+    connection_id: Optional[int] = Form(None),
+    notes: Optional[str] = Form(None),
+    file: UploadFile = File(...),
+):
+    customer = None
+    if customer_id:
+        customer = execute_query_single(
+            "SELECT id, name FROM customers WHERE id = %s AND is_active = true",
+            (customer_id,),
+        )
+        if not customer:
+            raise HTTPException(status_code=404, detail="Customer not found")
+
+    if connection_id:
+        connection = execute_query_single(
+            """
+            SELECT id, customer_id
+            FROM internet_connections_connections
+            WHERE id = %s
+              AND deleted_at IS NULL
+            """,
+            (connection_id,),
+        )
+        if not connection:
+            raise HTTPException(status_code=404, detail="Connection not found")
+        if customer_id and connection.get("customer_id") not in (None, customer_id):
+            raise HTTPException(status_code=400, detail="Connection belongs to a different customer")
+
+    original_filename = str(file.filename or "").strip()
+    suffix = Path(original_filename).suffix.lower()
+    if suffix not in INTERNET_CUSTOMER_DOC_EXTENSIONS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Kun tekstfiler er tilladt ({', '.join(sorted(INTERNET_CUSTOMER_DOC_EXTENSIONS))})",
+        )
+
+    upload_dir = _internet_customer_doc_dir()
+    safe_name = _sanitize_upload_name(original_filename)
+    customer_prefix = str(customer_id) if customer_id else "shared"
+    stored_name = f"{customer_prefix}_{int(date.today().strftime('%Y%m%d'))}_{safe_name}"
+    target = upload_dir / stored_name
+
+    total_size = 0
+    max_size = settings.EMAIL_MAX_UPLOAD_SIZE_MB * 1024 * 1024
+    try:
+        with open(target, "wb") as handle:
+            while chunk := await file.read(8192):
+                total_size += len(chunk)
+                if total_size > max_size:
+                    target.unlink(missing_ok=True)
+                    raise HTTPException(
+                        status_code=413,
+                        detail=f"Fil for stor (max {settings.EMAIL_MAX_UPLOAD_SIZE_MB} MB)",
+                    )
+                handle.write(chunk)
+
+        checksum = ollama_service.calculate_file_checksum(target)
+        existing = execute_query_single(
+            """
+            SELECT id
+            FROM internet_connections_customer_documents
+            WHERE customer_id = %s
+              AND checksum = %s
+              AND deleted_at IS NULL
+            LIMIT 1
+            """,
+            (customer_id, checksum),
+        )
+        if existing and customer_id:
+            target.unlink(missing_ok=True)
+            return {
+                "status": "duplicate",
+                "document_id": int(existing["id"]),
+                "message": "Filen er allerede uploadet paa denne kunde",
+            }
+        if not customer_id:
+            existing_shared = execute_query_single(
+                """
+                SELECT id
+                FROM internet_connections_customer_documents
+                WHERE customer_id IS NULL
+                  AND checksum = %s
+                  AND deleted_at IS NULL
+                LIMIT 1
+                """,
+                (checksum,),
+            )
+            if existing_shared:
+                target.unlink(missing_ok=True)
+                return {
+                    "status": "duplicate",
+                    "document_id": int(existing_shared["id"]),
+                    "message": "Filen er allerede uploadet i det delte arkiv",
+                }
+
+        extracted_text = await ollama_service._extract_text_from_file(target)
+        mime_type = ollama_service._get_mime_type(target)
+        document_id = execute_insert(
+            """
+            INSERT INTO internet_connections_customer_documents (
+                customer_id,
+                connection_id,
+                filename,
+                original_filename,
+                file_path,
+                file_size,
+                mime_type,
+                checksum,
+                extracted_text,
+                notes
+            )
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+            RETURNING id
+            """,
+            (
+                customer_id,
+                connection_id,
+                stored_name,
+                original_filename,
+                str(target),
+                total_size,
+                mime_type,
+                checksum,
+                extracted_text,
+                str(notes or "").strip() or None,
+            ),
+        )
+        segment_count = _index_customer_document_segments(int(document_id), extracted_text)
+        return {
+            "status": "uploaded",
+            "document_id": int(document_id),
+            "filename": original_filename,
+            "segment_count": segment_count,
+            "customer": {"id": int(customer["id"]), "name": customer["name"]} if customer else None,
+        }
+    except HTTPException:
+        raise
+    except Exception as exc:
+        target.unlink(missing_ok=True)
+        logger.exception("Customer document upload failed")
+        raise HTTPException(status_code=500, detail=f"Upload failed: {exc}") from exc
+
+
+@router.get("/internet-connections/migration-wizard-v2/context")
+async def get_migration_wizard_v2_context(
+    customer_id: Optional[int] = Query(None, ge=1),
+    query: Optional[str] = Query(None),
+):
+    customer = None
+    customer_name = ""
+    if customer_id:
+        customer = execute_query_single(
+            """
+            SELECT id, name
+            FROM customers
+            WHERE id = %s
+              AND is_active = true
+            """,
+            (customer_id,),
+        )
+        if not customer:
+            raise HTTPException(status_code=404, detail="Customer not found")
+        customer_name = str(customer.get("name") or "")
+
+    if customer_id:
+        document_payload = await _build_customer_document_hits(customer_id, customer_name, query)
+        invoice_hits = await _build_invoice_hits(customer_id, customer_name, query)
+    else:
+        rows = execute_query(
+            """
+            SELECT id, customer_id, original_filename, file_size, mime_type, notes, created_at, extracted_text
+            FROM internet_connections_customer_documents
+            WHERE deleted_at IS NULL
+            ORDER BY created_at DESC, id DESC
+            LIMIT 50
+            """
+        ) or []
+        documents = []
+        for row in rows:
+            item = dict(row)
+            item["segment_count"] = _ensure_document_segments(int(item["id"]), item.get("extracted_text"))
+            item.pop("extracted_text", None)
+            documents.append(item)
+        segment_rows = execute_query(
+            """
+            SELECT
+                seg.id AS segment_id,
+                seg.document_id,
+                seg.block_index,
+                seg.block_title AS title,
+                seg.content,
+                seg.ip_addresses,
+                seg.cidr_blocks,
+                seg.references_json AS references,
+                seg.socket_numbers
+            FROM internet_connections_customer_document_segments seg
+            JOIN internet_connections_customer_documents doc ON doc.id = seg.document_id
+            WHERE doc.deleted_at IS NULL
+            ORDER BY doc.created_at DESC, seg.block_index ASC
+            LIMIT 30
+            """
+        ) or []
+        segment_hits = []
+        for row in segment_rows:
+            snippet = re.sub(r"\s+", " ", str(row.get("content") or "")[:240]).strip()
+            segment_hits.append(
+                {
+                    "segment_id": int(row["segment_id"]),
+                    "document_id": int(row["document_id"]),
+                    "block_index": int(row.get("block_index") or 0),
+                    "title": row.get("title") or f"Blok {int(row.get('block_index') or 0) + 1}",
+                    "score": 0,
+                    "snippet": snippet,
+                    "ip_addresses": [str(item) for item in (row.get("ip_addresses") or [])],
+                    "cidr_blocks": [str(item) for item in (row.get("cidr_blocks") or [])],
+                    "references": [str(item) for item in (row.get("references") or [])],
+                    "socket_numbers": [str(item) for item in (row.get("socket_numbers") or [])],
+                }
+            )
+        document_payload = {"documents": documents, "snippets": [], "segments": segment_hits}
+        invoice_hits = []
+
+    summary_source_parts = []
+    if document_payload["snippets"]:
+        summary_source_parts.append("Kundefiler:\n" + "\n".join(document_payload["snippets"][:8]))
+    if invoice_hits:
+        invoice_lines = []
+        for item in invoice_hits[:5]:
+            base = f"{item['invoice_date']} {item['vendor_name']} {item['invoice_number']}"
+            if item["snippets"]:
+                invoice_lines.append(base + ": " + " | ".join(item["snippets"]))
+            else:
+                invoice_lines.append(base)
+        summary_source_parts.append("Fakturaer:\n" + "\n".join(invoice_lines))
+
+    ai_summary = ""
+    if summary_source_parts:
+        summary_input = (
+            f"Kunde: {customer_name}\n"
+            f"Sporgsmaal: {query or 'Vis relevant historik om internetforbindelser, adresser og gamle noter'}\n\n"
+            + "\n\n".join(summary_source_parts)
+        )
+        ai_summary = await ollama_service.generate_summary(summary_input)
+
+    return {
+        "customer": {"id": int(customer["id"]), "name": customer_name} if customer else None,
+        "query": query,
+        "documents": document_payload["documents"],
+        "document_snippets": document_payload["snippets"],
+        "segment_hits": document_payload["segments"],
+        "invoice_hits": invoice_hits,
+        "ai_summary": ai_summary,
+    }
diff --git a/app/modules/internet_connections/frontend/views.py b/app/modules/internet_connections/frontend/views.py
new file mode 100644
index 0000000..b3ad5a5
--- /dev/null
+++ b/app/modules/internet_connections/frontend/views.py
@@ -0,0 +1,33 @@
+import logging
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+templates = Jinja2Templates(directory="app")
+
+
+@router.get("/economy/internet-connections", response_class=HTMLResponse)
+async def internet_connections_index(request: Request):
+    return templates.TemplateResponse(
+        "modules/internet_connections/templates/index.html",
+        {"request": request, "title": "Internetforbindelser"},
+    )
+
+
+@router.get("/economy/internet-connections/{connection_id}", response_class=HTMLResponse)
+async def internet_connection_detail(request: Request, connection_id: int):
+    return templates.TemplateResponse(
+        "modules/internet_connections/templates/detail.html",
+        {"request": request, "title": "Forbindelsesdetaljer", "connection_id": connection_id},
+    )
+
+
+@router.get("/data-migration/internet-wizard-v2", response_class=HTMLResponse)
+async def internet_connection_migration_wizard_v2(request: Request):
+    return templates.TemplateResponse(
+        "modules/internet_connections/templates/migration_wizard_v2.html",
+        {"request": request, "title": "Internet Wizard v2"},
+    )
diff --git a/app/modules/internet_connections/module.json b/app/modules/internet_connections/module.json
new file mode 100644
index 0000000..929435e
--- /dev/null
+++ b/app/modules/internet_connections/module.json
@@ -0,0 +1,11 @@
+{
+  "name": "internet_connections",
+  "version": "0.1.0",
+  "description": "Modul til administration af internetforbindelser, IP-adresser og priser",
+  "author": "BMC Networks",
+  "enabled": true,
+  "dependencies": [],
+  "table_prefix": "internet_connections_",
+  "api_prefix": "/api/v1/internet-connections",
+  "tags": ["Internetforbindelser"]
+}
diff --git a/app/modules/internet_connections/templates/detail.html b/app/modules/internet_connections/templates/detail.html
new file mode 100644
index 0000000..bdc8cd7
--- /dev/null
+++ b/app/modules/internet_connections/templates/detail.html
@@ -0,0 +1,2104 @@
+{% extends "shared/frontend/base.html" %}
+
+{% block title %}Forbindelsesdetaljer{% endblock %}
+
+{% block extra_css %}
+<style>
+  .detail-hero {
+    background:
+      radial-gradient(circle at top right, rgba(15, 76, 117, 0.18), transparent 34%),
+      linear-gradient(135deg, rgba(15, 76, 117, 0.1), rgba(255, 255, 255, 0.02));
+    border: 1px solid rgba(15, 76, 117, 0.14);
+    border-radius: 24px;
+    padding: 1.5rem;
+    box-shadow: 0 16px 36px rgba(15, 76, 117, 0.08);
+  }
+
+  .detail-panel {
+    background: var(--bg-card);
+    border: 1px solid rgba(15, 76, 117, 0.12);
+    border-radius: 20px;
+    box-shadow: 0 14px 32px rgba(15, 76, 117, 0.06);
+  }
+
+  .detail-metric {
+    background: linear-gradient(180deg, rgba(15, 76, 117, 0.04), rgba(15, 76, 117, 0.01));
+    border: 1px solid rgba(15, 76, 117, 0.1);
+    border-radius: 16px;
+    padding: 1rem;
+    height: 100%;
+  }
+
+  .detail-metric-label {
+    color: var(--text-secondary);
+    font-size: 0.76rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .detail-metric-value {
+    color: var(--text-primary);
+    font-size: 1.35rem;
+    font-weight: 700;
+  }
+
+  .detail-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+    gap: 0.8rem;
+  }
+
+  .detail-grid-card {
+    border: 1px solid rgba(15, 76, 117, 0.1);
+    border-radius: 14px;
+    background: rgba(15, 76, 117, 0.03);
+    padding: 0.85rem;
+  }
+
+  .detail-grid-card.editing {
+    border-color: rgba(15, 76, 117, 0.28);
+    background: rgba(15, 76, 117, 0.06);
+  }
+
+  .detail-grid-card .label {
+    display: block;
+    color: var(--text-secondary);
+    font-size: 0.74rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: 0.25rem;
+  }
+
+  .detail-grid-card .value {
+    color: var(--text-primary);
+    font-weight: 600;
+  }
+
+  .status-pill {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.35rem;
+    padding: 0.35rem 0.7rem;
+    border-radius: 999px;
+    font-size: 0.75rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .status-pill.active {
+    background: rgba(25, 135, 84, 0.12);
+    color: #146c43;
+  }
+
+  .status-pill.inactive {
+    background: rgba(108, 117, 125, 0.14);
+    color: #495057;
+  }
+
+  .status-pill.pending,
+  .status-pill.planned {
+    background: rgba(255, 193, 7, 0.18);
+    color: #997404;
+  }
+
+  .status-pill.terminated,
+  .status-pill.cancelled {
+    background: rgba(220, 53, 69, 0.12);
+    color: #b02a37;
+  }
+
+  .timeline-item {
+    border-left: 3px solid rgba(15, 76, 117, 0.25);
+    padding-left: 1rem;
+    margin-left: 0.5rem;
+    margin-bottom: 1rem;
+  }
+
+  .sticky-sidebar {
+    position: sticky;
+    top: 1rem;
+  }
+
+  .lookup-hint {
+    font-size: 0.78rem;
+    color: var(--text-secondary);
+    margin-top: 0.35rem;
+  }
+
+  .range-edit-grid {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 0.5rem;
+    margin-top: 0.75rem;
+  }
+
+  .detail-read-layout {
+    display: flex;
+    flex-direction: column;
+    gap: 0.9rem;
+  }
+
+  .detail-read-strip {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.55rem;
+    padding-bottom: 0.2rem;
+  }
+
+  .detail-read-chip {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.45rem;
+    min-height: 42px;
+    padding: 0.55rem 0.8rem;
+    border: 1px solid rgba(15, 76, 117, 0.1);
+    border-radius: 14px;
+    background: rgba(15, 76, 117, 0.03);
+    line-height: 1.2;
+  }
+
+  .detail-read-chip .label {
+    font-size: 0.7rem;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: var(--text-secondary);
+    font-weight: 700;
+    white-space: nowrap;
+  }
+
+  .detail-read-chip .value {
+    font-size: 0.96rem;
+    color: var(--text-primary);
+    font-weight: 600;
+  }
+
+  .detail-read-grid {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 0.8rem 1.2rem;
+  }
+
+  .detail-read-row {
+    display: grid;
+    grid-template-columns: 120px minmax(0, 1fr);
+    gap: 0.7rem;
+    align-items: start;
+    padding: 0.15rem 0;
+    border-bottom: 1px solid rgba(15, 76, 117, 0.08);
+  }
+
+  .detail-read-row.full {
+    grid-column: 1 / -1;
+  }
+
+  .detail-read-row:last-child,
+  .detail-read-grid > .detail-read-row:nth-last-child(2):nth-child(odd) {
+    border-bottom: 0;
+  }
+
+  .detail-read-row .label {
+    font-size: 0.73rem;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: var(--text-secondary);
+    font-weight: 700;
+    padding-top: 0.2rem;
+  }
+
+  .detail-read-row .value {
+    font-size: 0.98rem;
+    color: var(--text-primary);
+    font-weight: 600;
+    word-break: break-word;
+  }
+
+  .detail-read-muted {
+    color: var(--text-secondary);
+    font-weight: 500;
+  }
+
+  .wizard-section {
+    border: 1px solid rgba(15, 76, 117, 0.1);
+    border-radius: 16px;
+    background: linear-gradient(180deg, rgba(15, 76, 117, 0.03), rgba(15, 76, 117, 0.01));
+    padding: 1rem;
+  }
+
+  .wizard-section-title {
+    font-size: 0.78rem;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    color: var(--text-secondary);
+    font-weight: 700;
+    margin-bottom: 0.75rem;
+  }
+
+  @media (max-width: 991.98px) {
+    .detail-read-grid {
+      grid-template-columns: 1fr;
+    }
+
+    .detail-read-row,
+    .detail-read-row.full {
+      grid-template-columns: 1fr;
+      gap: 0.2rem;
+    }
+  }
+</style>
+{% endblock %}
+
+{% block content %}
+<div class="container-fluid py-4">
+  <div class="detail-hero mb-4">
+      <div class="d-flex flex-column flex-xl-row justify-content-between align-items-xl-start gap-3">
+      <div>
+        <div class="small text-uppercase fw-semibold text-muted mb-2">Internetforbindelse</div>
+        <h2 class="h3 mb-1" id="detailName">Indlæser...</h2>
+        <div class="text-muted" id="detailSubtitle">Henter forbindelsesdata...</div>
+        <div class="small mt-2 text-muted" id="detailSaveFeedback" role="status"></div>
+      </div>
+      <div class="d-flex gap-2 flex-wrap">
+        <a href="/economy/internet-connections" class="btn btn-outline-secondary">
+          <i class="bi bi-arrow-left me-1"></i>Tilbage
+        </a>
+        <button class="btn btn-primary d-none" id="openBmcnetWizardBtn" type="button" onclick="openBmcnetWizard()">
+          <i class="bi bi-diagram-3 me-1"></i>Ny BMCnet
+        </button>
+        <button class="btn btn-outline-primary" id="editCoreDetailsBtn" type="button" onclick="toggleCoreEdit(true)">
+          <i class="bi bi-pencil me-1"></i>Rediger
+        </button>
+        <button class="btn btn-outline-secondary d-none" id="cancelCoreDetailsBtn" type="button" onclick="toggleCoreEdit(false)">
+          <i class="bi bi-x-lg me-1"></i>Annuller
+        </button>
+        <button class="btn btn-primary d-none" id="saveCoreDetailsBtn" type="button" onclick="saveCoreDetails()">
+          <i class="bi bi-save me-1"></i>Gem ændringer
+        </button>
+      </div>
+    </div>
+  </div>
+
+  <div class="row g-4 mb-4">
+    <div class="col-6 col-xl-3">
+      <div class="detail-metric">
+        <div class="detail-metric-label">Salgspris</div>
+        <div class="detail-metric-value" id="metricSales">0 kr.</div>
+      </div>
+    </div>
+    <div class="col-6 col-xl-3">
+      <div class="detail-metric">
+        <div class="detail-metric-label">Indkøbspris</div>
+        <div class="detail-metric-value" id="metricPurchase">0 kr.</div>
+      </div>
+    </div>
+    <div class="col-6 col-xl-3">
+      <div class="detail-metric">
+        <div class="detail-metric-label">Dækningsbidrag</div>
+        <div class="detail-metric-value" id="metricMargin">0 kr.</div>
+      </div>
+    </div>
+    <div class="col-6 col-xl-3">
+      <div class="detail-metric">
+        <div class="detail-metric-label">IP-adresser</div>
+        <div class="detail-metric-value" id="metricIps">0</div>
+      </div>
+    </div>
+    <div class="col-12 col-xl-3">
+      <div class="detail-metric">
+        <div class="detail-metric-label">Båndbredde i brug</div>
+        <div class="detail-metric-value" id="metricBandwidth">0 / 0 Mbps</div>
+        <div class="small text-muted mt-1" id="metricBandwidthSub">0%</div>
+      </div>
+    </div>
+  </div>
+
+  <div class="row g-4">
+    <div class="col-xl-8">
+      <div class="detail-panel p-4 mb-4">
+        <div class="d-flex justify-content-between align-items-center mb-3">
+          <h5 class="mb-0">Grunddata</h5>
+          <span id="detailStatusBadge" class="status-pill inactive">-</span>
+        </div>
+        <div id="coreReadView" class="detail-read-layout mb-2"></div>
+        <div class="row g-3 d-none" id="coreEditForm">
+          <div class="col-md-6">
+            <label class="form-label">Navn</label>
+            <input type="text" class="form-control" id="fieldName">
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Leverandør</label>
+            <input type="text" class="form-control" id="fieldProvider">
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Kredsløb</label>
+            <input type="text" class="form-control" id="fieldCircuit">
+          </div>
+          <div class="col-md-6">
+            <label class="form-label">Adresse</label>
+            <input type="text" class="form-control" id="fieldAddress">
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Kunde</label>
+            <input type="text" class="form-control" id="fieldCustomerLookup" list="customerLookupList" placeholder="Søg kunde">
+            <input type="hidden" id="fieldCustomerId">
+            <div class="lookup-hint">Søg på kundenavn og behold ID i baggrunden.</div>
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Parent-forbindelse</label>
+            <input type="text" class="form-control" id="fieldParentLookup" list="connectionLookupList" placeholder="Søg forbindelse">
+            <input type="hidden" id="fieldParentId">
+            <div class="lookup-hint">Bruges hvis denne ligger under en hovedforbindelse.</div>
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Forbindelsestype</label>
+            <input type="text" class="form-control" id="fieldConnectionType">
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Teknologi</label>
+            <input type="text" class="form-control" id="fieldTechnology">
+          </div>
+          <div class="col-md-2">
+            <label class="form-label">Download</label>
+            <input type="number" class="form-control" id="fieldDownload">
+          </div>
+          <div class="col-md-2">
+            <label class="form-label">Upload</label>
+            <input type="number" class="form-control" id="fieldUpload">
+          </div>
+          <div class="col-md-2">
+            <label class="form-label">Fallback Mbps</label>
+            <input type="number" class="form-control" id="fieldSpeed">
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Status</label>
+            <select class="form-select" id="fieldStatus">
+              <option value="active">Aktiv</option>
+              <option value="planned">Planlagt</option>
+              <option value="pending">Afventer</option>
+              <option value="inactive">Inaktiv</option>
+              <option value="terminated">Opsagt</option>
+            </select>
+          </div>
+          <div class="col-md-6">
+            <label class="form-label">Overvågning</label>
+            <input type="text" class="form-control" id="fieldMonitoringUrl" placeholder="https://...">
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Allokering</label>
+            <select class="form-select" id="fieldAllocationModel">
+              <option value="dedicated">Dedikeret</option>
+              <option value="shared">Delt</option>
+            </select>
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Værdi-type</label>
+            <select class="form-select" id="fieldValueType" onchange="toggleValueFields()">
+              <option value="subscription">Abonnement</option>
+              <option value="bmc_networks">BMC Networks</option>
+              <option value="delefiber">Delefiber</option>
+              <option value="other">Anden</option>
+            </select>
+          </div>
+          <div class="col-md-6" id="fieldValueLabelWrap">
+            <label class="form-label">Værdi / klassifikation</label>
+            <input type="text" class="form-control" id="fieldValueLabel" placeholder="fx delt transit, intern backbone">
+          </div>
+          <div class="col-md-6 d-none" id="fieldSubscriptionWrap">
+            <label class="form-label">Abonnement</label>
+            <input type="text" class="form-control" id="fieldSubscriptionLookup" list="subscriptionLookupList" placeholder="Søg abonnement">
+            <input type="hidden" id="fieldSubscriptionId">
+            <div class="lookup-hint">Forbindelsen må kun have ét aktivt abonnement direkte koblet på.</div>
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Kontrakt start</label>
+            <input type="date" class="form-control" id="fieldContractStart">
+          </div>
+          <div class="col-md-3">
+            <label class="form-label">Kontrakt slut</label>
+            <input type="date" class="form-control" id="fieldContractEnd">
+          </div>
+          <div class="col-12">
+            <label class="form-label">Noter</label>
+            <textarea class="form-control" id="fieldNotes" rows="3"></textarea>
+          </div>
+        </div>
+      </div>
+
+      <div class="detail-panel p-4 mb-4">
+        <div class="d-flex justify-content-between align-items-center mb-3">
+          <div>
+            <h5 class="mb-0">IP-ranges</h5>
+            <div class="small text-muted" id="rangeCreateFeedback"></div>
+          </div>
+          <button class="btn btn-sm btn-outline-primary" type="button" data-bs-toggle="collapse" data-bs-target="#createRangeForm">Tilføj range</button>
+        </div>
+        <div class="collapse mb-3" id="createRangeForm">
+          <div class="row g-2">
+            <div class="col-md-3">
+              <label class="form-label small text-muted mb-1" for="rangeCidrInput">CIDR</label>
+              <input type="text" class="form-control" id="rangeCidrInput" placeholder="fx 87.116.1.200/29">
+            </div>
+            <div class="col-md-3">
+              <label class="form-label small text-muted mb-1" for="rangeNameInput">Navn</label>
+              <input type="text" class="form-control" id="rangeNameInput" placeholder="Valgfrit, ellers bruges CIDR">
+            </div>
+            <div class="col-md-3">
+              <label class="form-label small text-muted mb-1" for="rangeProviderReferenceInput">Provider ref.</label>
+              <input type="text" class="form-control" id="rangeProviderReferenceInput" placeholder="Provider ref.">
+            </div>
+            <div class="col-md-3">
+              <label class="form-label small text-muted mb-1" for="rangeContractInput">Kontrakt</label>
+              <input type="text" class="form-control" id="rangeContractInput" placeholder="Kontrakt">
+            </div>
+            <div class="col-md-4">
+              <label class="form-label small text-muted mb-1" for="rangeServiceAddressInput">Serviceadresse</label>
+              <input type="text" class="form-control" id="rangeServiceAddressInput" placeholder="Serviceadresse">
+            </div>
+            <div class="col-md-4">
+              <label class="form-label small text-muted mb-1" for="rangeDescriptionInput">Beskrivelse</label>
+              <input type="text" class="form-control" id="rangeDescriptionInput" placeholder="Beskrivelse">
+            </div>
+            <div class="col-md-4">
+              <label class="form-label small text-muted mb-1" for="rangeCustomerLookupInput">Kunde på range</label>
+              <input type="text" class="form-control" id="rangeCustomerLookupInput" list="customerLookupList" placeholder="Kunde på range">
+              <input type="hidden" id="rangeCustomerIdInput">
+            </div>
+            <div class="col-md-2">
+              <label class="form-label small text-muted mb-1" for="rangeMonthlyCostInput">Kost</label>
+              <input type="number" class="form-control" id="rangeMonthlyCostInput" placeholder="Kost">
+            </div>
+            <div class="col-md-2">
+              <label class="form-label small text-muted mb-1" for="rangeSalesPriceInput">Salg</label>
+              <input type="number" class="form-control" id="rangeSalesPriceInput" placeholder="Salg">
+            </div>
+            <div class="col-md-2"><button class="btn btn-primary w-100" id="createRangeButton" type="button" onclick="createRange()">Gem</button></div>
+          </div>
+        </div>
+        <div id="ipRangesList" class="detail-grid"></div>
+      </div>
+
+      <div class="detail-panel p-4 mb-4">
+        <div class="d-flex justify-content-between align-items-center mb-3">
+          <div>
+            <h5 class="mb-0">IP-adresser</h5>
+            <div class="small text-muted" id="ipAddressSummary">Indlæser...</div>
+          </div>
+          <button class="btn btn-sm btn-outline-primary" type="button" data-bs-toggle="collapse" data-bs-target="#createAddressForm">Tilføj IP</button>
+        </div>
+        <div class="collapse mb-3" id="createAddressForm">
+          <div class="row g-2">
+            <div class="col-md-3"><select class="form-select" id="addressRangeSelect"></select></div>
+            <div class="col-md-3"><input type="text" class="form-control" id="addressIpInput" placeholder="IP-adresse"></div>
+            <div class="col-md-2">
+              <select class="form-select" id="addressStatusInput">
+                <option value="available">Tilgængelig</option>
+                <option value="reserved">Reserveret</option>
+                <option value="in_use">I brug</option>
+              </select>
+            </div>
+            <div class="col-md-2"><input type="text" class="form-control" id="addressAssignedInput" placeholder="Label"></div>
+            <div class="col-md-3">
+              <input type="text" class="form-control" id="addressAssignedCustomerInput" list="customerLookupList" placeholder="Kunde">
+              <input type="hidden" id="addressAssignedCustomerIdInput">
+            </div>
+            <div class="col-md-3">
+              <input type="text" class="form-control" id="addressAssignedConnectionInput" list="connectionLookupList" placeholder="Forbindelse">
+              <input type="hidden" id="addressAssignedConnectionIdInput">
+            </div>
+            <div class="col-md-2"><button class="btn btn-primary w-100" type="button" onclick="createAddress()">Gem</button></div>
+          </div>
+        </div>
+        <div class="row g-2 mb-3">
+          <div class="col-md-6"><input type="search" class="form-control" id="addressSearchInput" placeholder="Søg IP, tildeling eller kommentar"></div>
+          <div class="col-md-3">
+            <select class="form-select" id="addressStatusFilter">
+              <option value="">Alle statusser</option>
+              <option value="available">Tilgængelig</option>
+              <option value="reserved">Reserveret</option>
+              <option value="in_use">I brug</option>
+            </select>
+          </div>
+          <div class="col-md-3"><button class="btn btn-light border w-100" type="button" onclick="resetAddressFilters()">Nulstil</button></div>
+        </div>
+        <div class="table-responsive">
+          <table class="table align-middle mb-0">
+            <thead class="table-light">
+              <tr>
+                <th>IP</th>
+                <th>Status</th>
+                <th>Abonnement</th>
+                <th>Firma</th>
+                <th></th>
+              </tr>
+            </thead>
+            <tbody id="ipAddressesTableBody">
+              <tr><td colspan="5" class="text-muted py-4">Indlæser...</td></tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+
+      <div class="detail-panel p-4 mb-4">
+        <div class="d-flex justify-content-between align-items-center mb-3">
+          <h5 class="mb-0">Pris og kontrakt</h5>
+          <div class="small text-muted" id="pricingFeedback"></div>
+        </div>
+        <div class="row g-2 mb-3">
+          <div class="col-md-3"><input type="date" class="form-control" id="pricingEffectiveDateInput"></div>
+          <div class="col-md-3"><input type="number" class="form-control" id="pricingPurchaseInput" placeholder="Indkøbspris"></div>
+          <div class="col-md-3"><input type="number" class="form-control" id="pricingSalesInput" placeholder="Salgspris"></div>
+          <div class="col-md-3"><input type="text" class="form-control" id="pricingNotesInput" placeholder="Note"></div>
+        </div>
+        <div class="mb-3">
+          <button class="btn btn-primary" type="button" onclick="createPricingEntry()">Gem prislinje</button>
+        </div>
+        <div class="detail-grid mb-3" id="pricingSummaryGrid"></div>
+        <div id="pricingHistoryList"></div>
+      </div>
+
+      <div class="detail-panel p-4">
+        <h5 class="mb-3">Historik</h5>
+        <div id="historyList"></div>
+      </div>
+    </div>
+
+    <div class="col-xl-4">
+      <div class="sticky-sidebar">
+        <div class="detail-panel p-4 mb-4">
+          <h5 class="mb-3">Relationer</h5>
+          <div class="detail-grid" id="relationGrid"></div>
+        </div>
+        <div class="detail-panel p-4 mb-4 d-none" id="bmcnetChildrenPanel">
+          <div class="d-flex justify-content-between align-items-center mb-3">
+            <h5 class="mb-0">BMCnet</h5>
+            <div class="d-flex align-items-center gap-2">
+              <span class="small text-muted" id="bmcnetChildrenCount">0 kunder</span>
+              <button class="btn btn-sm btn-outline-primary" type="button" onclick="openBmcnetWizard()">
+                <i class="bi bi-plus-lg me-1"></i>Ny BMCnet
+              </button>
+            </div>
+          </div>
+          <div class="detail-grid mb-3" id="bmcnetChildrenSummaryGrid"></div>
+          <div id="bmcnetChildrenList"></div>
+        </div>
+        <div class="detail-panel p-4">
+          <h5 class="mb-3">Kontraktoverblik</h5>
+          <div id="contractsOverviewList"></div>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>
+
+<datalist id="customerLookupList"></datalist>
+<datalist id="connectionLookupList"></datalist>
+<datalist id="subscriptionLookupList"></datalist>
+
+<div class="modal fade" id="bmcnetWizardModal" tabindex="-1" aria-hidden="true">
+  <div class="modal-dialog modal-xl modal-dialog-scrollable">
+    <div class="modal-content border-0 shadow-lg">
+      <div class="modal-header">
+        <div>
+          <div class="small text-uppercase text-muted fw-semibold">Hurtig Oprettelse</div>
+          <h5 class="modal-title mb-0">Ny BMCnet-forbindelse</h5>
+        </div>
+        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Luk"></button>
+      </div>
+      <div class="modal-body">
+        <div class="alert alert-info mb-3" id="bmcnetWizardIntro">
+          Opret en kunde-forbindelse direkte under denne delte hovedforbindelse, og reserver evt. et helt ledigt IP-range med det samme.
+        </div>
+        <div class="wizard-section mb-3">
+          <div class="wizard-section-title">0. Hovedforbindelse</div>
+          <div class="row g-2 align-items-end">
+            <div class="col-lg-8">
+              <label class="form-label">Brug denne hovedforbindelse</label>
+              <select class="form-select" id="bmcnetWizardSharedHeadSelect"></select>
+            </div>
+            <div class="col-lg-4">
+              <div class="small text-muted" id="bmcnetWizardHeadHint">Wizard’en bruger som standard den hovedforbindelse du står på nu.</div>
+            </div>
+          </div>
+        </div>
+        <div class="row g-3">
+          <div class="col-lg-6">
+            <div class="wizard-section h-100">
+              <div class="wizard-section-title">1. Kunde og service</div>
+              <div class="row g-2">
+                <div class="col-12">
+                  <label class="form-label">Kunde</label>
+                  <input type="text" class="form-control" id="bmcnetWizardCustomerLookup" list="customerLookupList" placeholder="Søg kunde">
+                  <input type="hidden" id="bmcnetWizardCustomerId">
+                </div>
+                <div class="col-12">
+                  <label class="form-label">Forbindelsesnavn</label>
+                  <input type="text" class="form-control" id="bmcnetWizardName" placeholder="fx BMCnet - Kunde">
+                </div>
+                <div class="col-12">
+                  <label class="form-label">Service</label>
+                  <input type="text" class="form-control" id="bmcnetWizardService" placeholder="fx Internet / Firewall / WAN">
+                </div>
+                <div class="col-12">
+                  <label class="form-label">Adresse</label>
+                  <input type="text" class="form-control" id="bmcnetWizardAddress" placeholder="Serviceadresse">
+                </div>
+              </div>
+            </div>
+          </div>
+          <div class="col-lg-6">
+            <div class="wizard-section h-100">
+              <div class="wizard-section-title">2. Abonnement</div>
+              <div class="row g-2">
+                <div class="col-md-6">
+                  <label class="form-label">Internetprodukt</label>
+                  <select class="form-select" id="bmcnetWizardInternetProduct"></select>
+                </div>
+                <div class="col-md-6">
+                  <label class="form-label">IP-produkt</label>
+                  <select class="form-select" id="bmcnetWizardIpProduct"></select>
+                </div>
+                <div class="col-md-4">
+                  <label class="form-label">Interval</label>
+                  <select class="form-select" id="bmcnetWizardBillingInterval">
+                    <option value="monthly">Måned</option>
+                    <option value="quarterly">Kvartal</option>
+                    <option value="yearly">År</option>
+                  </select>
+                </div>
+                <div class="col-md-4">
+                  <label class="form-label">Faktura dag</label>
+                  <input type="number" class="form-control" id="bmcnetWizardBillingDay" min="1" max="31" value="1">
+                </div>
+                <div class="col-md-4">
+                  <label class="form-label">Startdato</label>
+                  <input type="date" class="form-control" id="bmcnetWizardStartDate">
+                </div>
+                <div class="col-md-6">
+                  <label class="form-label">Pris internet</label>
+                  <input type="number" class="form-control" id="bmcnetWizardInternetPrice" placeholder="Standard fra produkt" step="0.01">
+                </div>
+                <div class="col-md-6">
+                  <label class="form-label">Pris IP-produkt</label>
+                  <input type="number" class="form-control" id="bmcnetWizardIpPrice" placeholder="Standard fra produkt" step="0.01">
+                </div>
+                <div class="col-12">
+                  <label class="form-label">Noter</label>
+                  <textarea class="form-control" id="bmcnetWizardNotes" rows="3" placeholder="Interne noter"></textarea>
+                </div>
+              </div>
+            </div>
+          </div>
+          <div class="col-12">
+            <div class="wizard-section">
+              <div class="wizard-section-title">3. IP-range</div>
+              <div class="row g-2 align-items-end" id="bmcnetWizardRangeWrap">
+                <div class="col-lg-8">
+                  <label class="form-label">Ledigt range på hovedforbindelsen</label>
+                  <select class="form-select" id="bmcnetWizardRangeSelect"></select>
+                </div>
+                <div class="col-lg-4">
+                  <div class="small text-muted" id="bmcnetWizardRangeHint">Vælg et helt ledigt range, hvis kunden skal have egne IP-adresser.</div>
+                </div>
+              </div>
+              <div class="row g-2 align-items-end d-none" id="bmcnetWizardIpWrap">
+                <div class="col-lg-8">
+                  <label class="form-label">Ledig IP på hovedadressens ranges</label>
+                  <select class="form-select" id="bmcnetWizardIpSelect"></select>
+                </div>
+                <div class="col-lg-4">
+                  <div class="form-check mt-4">
+                    <input class="form-check-input" type="checkbox" id="bmcnetWizardGatewayCheckbox">
+                    <label class="form-check-label" for="bmcnetWizardGatewayCheckbox">Marker som BMCnet kunde gateway</label>
+                  </div>
+                  <div class="small text-muted mt-2" id="bmcnetWizardIpHint">Vælg en ledig IP fra alle ranges på hovedadressen.</div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+        <div class="small mt-3" id="bmcnetWizardFeedback"></div>
+      </div>
+      <div class="modal-footer">
+        <button type="button" class="btn btn-outline-secondary" data-bs-dismiss="modal">Luk</button>
+        <button type="button" class="btn btn-primary" id="bmcnetWizardSubmitBtn" onclick="createBmcnetConnection()">
+          <i class="bi bi-check2-circle me-1"></i>Opret BMCnet-forbindelse
+        </button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<script>
+  const connectionId = {{ connection_id }};
+  let currentConnection = null;
+  let currentAddresses = [];
+  let currentRanges = [];
+  let currentBmcnetChildren = [];
+  let editingAddressId = null;
+  let coreEditMode = false;
+  let customerOptions = [];
+  let connectionOptions = [];
+  let subscriptionOptions = [];
+  let bmcnetWizardProducts = [];
+  let bmcnetWizardModal = null;
+  let bmcnetWizardRangesByHead = {};
+  let bmcnetWizardAddressesByHead = {};
+
+  function formatDKK(value) {
+    return Number(value || 0).toLocaleString('da-DK', { style: 'currency', currency: 'DKK', minimumFractionDigits: 0 });
+  }
+
+  function formatDate(value) {
+    if (!value) return '-';
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) return value;
+    return date.toLocaleDateString('da-DK');
+  }
+
+  function formatDateTime(value) {
+    if (!value) return '-';
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) return value;
+    return date.toLocaleString('da-DK');
+  }
+
+  function formatSpeed(item) {
+    const download = Number(item?.download_mbps || 0);
+    const upload = Number(item?.upload_mbps || 0);
+    const fallback = Number(item?.speed_mbps || 0);
+
+    if (download > 0 || upload > 0) {
+      if (download > 0 && upload > 0) return `${download}/${upload} Mbps`;
+      return `${download || upload} Mbps`;
+    }
+    if (fallback > 0) return `${fallback} Mbps`;
+    return '-';
+  }
+
+  function formatIpRole(value) {
+    const key = String(value || '').trim().toLowerCase();
+    const labels = {
+      bmcnet_gateway: 'BMCnet gateway',
+      webserver: 'Webserver',
+      mailserver: 'Mailserver',
+      unifi: 'Unifi',
+      firewall: 'Firewall',
+      vpn: 'VPN',
+      service: 'Service',
+      subscription: 'Abonnement',
+    };
+    return labels[key] || (value || '-');
+  }
+
+  function escapeHtml(value) {
+    return String(value || '')
+      .replaceAll('&', '&amp;')
+      .replaceAll('<', '&lt;')
+      .replaceAll('>', '&gt;')
+      .replaceAll('"', '&quot;')
+      .replaceAll("'", '&#39;');
+  }
+
+  async function safeJson(response, fallback) {
+    if (!response || !response.ok) return fallback;
+    try {
+      return await response.json();
+    } catch {
+      return fallback;
+    }
+  }
+
+  async function extractErrorMessage(response, fallback) {
+    try {
+      const payload = await response.clone().json();
+      if (typeof payload?.detail === 'string' && payload.detail.trim()) return payload.detail.trim();
+      if (Array.isArray(payload?.detail)) {
+        const validation = payload.detail
+          .map((item) => item?.msg || item?.message || '')
+          .filter(Boolean)
+          .join(', ');
+        if (validation) return validation;
+      }
+    } catch (_) {}
+
+    try {
+      const text = (await response.text()).trim();
+      if (text) return text;
+    } catch (_) {}
+    return fallback;
+  }
+
+  function formatHistoryValue(field, value) {
+    if (value === null || value === undefined || value === '') return 'Tom';
+    if (['monthly_cost', 'purchase_price', 'sales_price'].includes(field)) {
+      return formatDKK(value);
+    }
+    if (['speed_mbps', 'download_mbps', 'upload_mbps'].includes(field)) {
+      return `${value} Mbps`;
+    }
+    if (field === 'allocation_model') {
+      return value === 'shared' ? 'Delt' : 'Dedikeret';
+    }
+    if (field === 'value_type') {
+      const labels = {
+        subscription: 'Abonnement',
+        bmc_networks: 'BMC Networks',
+        delefiber: 'Delefiber',
+        other: 'Anden',
+      };
+      return labels[String(value)] || String(value);
+    }
+    if (field === 'status') {
+      const labels = {
+        active: 'Aktiv',
+        planned: 'Planlagt',
+        pending: 'Afventer',
+        inactive: 'Inaktiv',
+        terminated: 'Opsagt',
+        cancelled: 'Annulleret',
+      };
+      return labels[String(value)] || String(value);
+    }
+    return String(value);
+  }
+
+  function renderHistoryDetails(entry) {
+    const details = entry && entry.details && typeof entry.details === 'object' ? entry.details : {};
+    const changes = details.changes && typeof details.changes === 'object' ? details.changes : null;
+    const labels = {
+      customer_id: 'Kunde',
+      address: 'Adresse',
+      monthly_cost: 'Kostpris',
+      technology: 'Teknologi',
+      connection_type: 'Forbindelsestype',
+      circuit_number: 'Reference',
+      speed_mbps: 'Fallback hastighed',
+      download_mbps: 'Download',
+      upload_mbps: 'Upload',
+      status: 'Status',
+      allocation_model: 'Allokering',
+      value_type: 'Værdi-type',
+      provider_reference: 'Provider-ref.',
+      contract_number: 'Kontrakt',
+      service_address: 'Serviceadresse',
+    };
+
+    const meta = [];
+    if (details.reference) meta.push(`Ref: ${details.reference}`);
+    if (details.cidr) meta.push(`Range: ${details.cidr}`);
+    if (details.provider_reference && !details.reference) meta.push(`Provider-ref.: ${details.provider_reference}`);
+    if (details.contract_number) meta.push(`Kontrakt: ${details.contract_number}`);
+
+    const metaHtml = meta.length
+      ? `<div class="small text-muted mt-1">${meta.join(' · ')}</div>`
+      : '';
+
+    if (!changes || !Object.keys(changes).length) {
+      return metaHtml;
+    }
+
+    const changesHtml = Object.entries(changes).map(([field, change]) => `
+      <div class="small mt-1">
+        <strong>${labels[field] || field}</strong>: ${formatHistoryValue(field, change.from)} → ${formatHistoryValue(field, change.to)}
+      </div>
+    `).join('');
+
+    return `${metaHtml}<div class="mt-2">${changesHtml}</div>`;
+  }
+
+  function setStatusBadge(status) {
+    const el = document.getElementById('detailStatusBadge');
+    const value = String(status || 'inactive').toLowerCase();
+    const labels = {
+      active: 'Aktiv',
+      planned: 'Planlagt',
+      pending: 'Afventer',
+      inactive: 'Inaktiv',
+      terminated: 'Opsagt',
+      cancelled: 'Annulleret',
+    };
+    el.className = `status-pill ${value}`;
+    el.textContent = labels[value] || value;
+  }
+
+  function buildLookupLabel(item) {
+    return `${item.id} · ${item.name || '-'}`;
+  }
+
+  function populateDatalist(listId, items) {
+    document.getElementById(listId).innerHTML = items
+      .map((item) => `<option value="${buildLookupLabel(item)}"></option>`)
+      .join('');
+  }
+
+  function buildSubscriptionLabel(item) {
+    return `${item.id} · ${item.subscription_number || '-'} · ${item.product_name || '-'} · ${item.customer_name || '-'}`;
+  }
+
+  function resolveLookupId(value, items) {
+    const raw = String(value || '').trim();
+    if (!raw) return null;
+    const idMatch = raw.match(/^(\d+)\b/);
+    if (idMatch) return Number(idMatch[1]);
+    const matched = items.find((item) => String(item.name || '').toLowerCase() === raw.toLowerCase());
+    return matched ? Number(matched.id) : null;
+  }
+
+  function bindLookupInput(textInputId, hiddenInputId, itemsRef) {
+    const textInput = document.getElementById(textInputId);
+    const hiddenInput = document.getElementById(hiddenInputId);
+    const sync = () => {
+      hiddenInput.value = resolveLookupId(textInput.value, itemsRef()) || '';
+    };
+    textInput.addEventListener('change', sync);
+    textInput.addEventListener('blur', sync);
+  }
+
+  function setLookupValue(textInputId, hiddenInputId, items, selectedId) {
+    const match = items.find((item) => Number(item.id) === Number(selectedId));
+    document.getElementById(textInputId).value = match ? buildLookupLabel(match) : '';
+    document.getElementById(hiddenInputId).value = selectedId || '';
+  }
+
+  function setSubscriptionValue(selectedId) {
+    const match = subscriptionOptions.find((item) => Number(item.id) === Number(selectedId));
+    document.getElementById('fieldSubscriptionLookup').value = match ? buildSubscriptionLabel(match) : '';
+    document.getElementById('fieldSubscriptionId').value = selectedId || '';
+  }
+
+  function resolveSubscriptionId(value) {
+    const raw = String(value || '').trim();
+    if (!raw) return null;
+    const idMatch = raw.match(/^(\d+)\b/);
+    if (idMatch) return Number(idMatch[1]);
+    const matched = subscriptionOptions.find((item) => buildSubscriptionLabel(item).toLowerCase() === raw.toLowerCase());
+    return matched ? Number(matched.id) : null;
+  }
+
+  async function loadLookups() {
+    const [customersResponse, connectionsResponse, subscriptionsResponse, productsResponse] = await Promise.all([
+      fetch('/api/v1/customers?limit=1000&is_active=true'),
+      fetch('/api/v1/internet-connections'),
+      fetch('/api/v1/internet-connections/subscription-options?status=active'),
+      fetch('/api/v1/products'),
+    ]);
+
+    const customersPayload = customersResponse.ok ? await customersResponse.json() : { customers: [] };
+    customerOptions = Array.isArray(customersPayload.customers) ? customersPayload.customers : [];
+    connectionOptions = connectionsResponse.ok ? await connectionsResponse.json() : [];
+    subscriptionOptions = subscriptionsResponse.ok ? await subscriptionsResponse.json() : [];
+    bmcnetWizardProducts = productsResponse.ok ? await productsResponse.json() : [];
+
+    populateDatalist('customerLookupList', customerOptions);
+    populateDatalist(
+      'connectionLookupList',
+      connectionOptions.filter((item) => Number(item.id) !== Number(connectionId))
+    );
+    document.getElementById('subscriptionLookupList').innerHTML = subscriptionOptions
+      .map((item) => `<option value="${buildSubscriptionLabel(item)}"></option>`)
+      .join('');
+    populateBmcnetWizardProducts();
+  }
+
+  function parseProductAttributes(raw) {
+    if (!raw) return {};
+    if (typeof raw === 'object') return raw;
+    try {
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed === 'object' ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+
+  function populateBmcnetWizardProducts() {
+    const internetSelect = document.getElementById('bmcnetWizardInternetProduct');
+    const ipSelect = document.getElementById('bmcnetWizardIpProduct');
+    if (!internetSelect || !ipSelect) return;
+
+    const internetProducts = bmcnetWizardProducts.filter((product) => {
+      const kind = parseProductAttributes(product.attributes_json)?.network?.kind;
+      return kind === 'internet_access';
+    });
+    const ipProducts = bmcnetWizardProducts.filter((product) => {
+      const kind = parseProductAttributes(product.attributes_json)?.network?.kind;
+      return kind === 'ip_allocation';
+    });
+
+    internetSelect.innerHTML = '<option value="">Vælg internetprodukt</option>' + internetProducts.map((product) => (
+      `<option value="${product.id}" data-price="${Number(product.sales_price || 0)}">${escapeHtml(product.name || '-')}</option>`
+    )).join('');
+    ipSelect.innerHTML = '<option value="">Intet IP-produkt</option>' + ipProducts.map((product) => (
+      `<option value="${product.id}" data-price="${Number(product.sales_price || 0)}">${escapeHtml(product.name || '-')}</option>`
+    )).join('');
+  }
+
+  function getSharedHeadOptions() {
+    return (connectionOptions || []).filter((item) => item?.is_shared_head);
+  }
+
+  async function loadRangesForSharedHead(sharedHeadId) {
+    const headId = Number(sharedHeadId || 0);
+    if (!headId) return [];
+    if (bmcnetWizardRangesByHead[headId]) {
+      return bmcnetWizardRangesByHead[headId];
+    }
+    const response = await fetch(`/api/v1/internet-connections/${headId}/ip-ranges`);
+    const ranges = response.ok ? await response.json() : [];
+    bmcnetWizardRangesByHead[headId] = Array.isArray(ranges) ? ranges : [];
+    return bmcnetWizardRangesByHead[headId];
+  }
+
+  async function loadAddressesForSharedHead(sharedHeadId) {
+    const headId = Number(sharedHeadId || 0);
+    if (!headId) return [];
+    if (bmcnetWizardAddressesByHead[headId]) {
+      return bmcnetWizardAddressesByHead[headId];
+    }
+    const response = await fetch(`/api/v1/internet-connections/${headId}/ip-addresses`);
+    const addresses = response.ok ? await response.json() : [];
+    bmcnetWizardAddressesByHead[headId] = Array.isArray(addresses) ? addresses : [];
+    return bmcnetWizardAddressesByHead[headId];
+  }
+
+  function filterAvailableBmcnetRanges(ranges) {
+    return (ranges || []).filter((range) =>
+      range
+      && range.belongs_to_connection !== false
+      && range.is_fully_available
+    );
+  }
+
+  function findWizardProduct(productId) {
+    return bmcnetWizardProducts.find((product) => Number(product.id) === Number(productId)) || null;
+  }
+
+  function isStaticWanIpProduct(productId) {
+    const product = findWizardProduct(productId);
+    if (!product) return false;
+    const attrs = parseProductAttributes(product.attributes_json);
+    const prefix = Number(attrs?.network?.ip_prefix_length || 0);
+    const text = `${product.name || ''} ${product.short_description || ''}`.toLowerCase();
+    return prefix === 32 || text.includes('statisk wan');
+  }
+
+  async function refreshBmcnetWizardIpState(sharedHeadId) {
+    const headId = Number(sharedHeadId || 0);
+    const head = getSharedHeadOptions().find((item) => Number(item.id) === headId) || currentConnection;
+    const selectedAddress = (document.getElementById('bmcnetWizardAddress').value || '').trim().toLowerCase();
+    const addresses = await loadAddressesForSharedHead(headId);
+    const availableIps = (addresses || []).filter((item) => {
+      if (String(item.status || '').toLowerCase() !== 'available') return false;
+      if (Number(item.range_connection_id || 0) !== headId) return false;
+      const serviceAddress = String(item.range_service_address || head?.address || '').trim().toLowerCase();
+      if (selectedAddress && serviceAddress && serviceAddress !== selectedAddress) return false;
+      return true;
+    });
+    const ipSelect = document.getElementById('bmcnetWizardIpSelect');
+    ipSelect.innerHTML = `<option value="">Ingen ledige IP'er</option>${availableIps.map((item) => `
+      <option value="${item.id}" data-head-id="${headId}" data-range-id="${item.range_id || ''}" data-ip="${escapeHtml(item.ip_address || '')}">
+        ${item.ip_address} · ${item.range_cidr || '-'}${item.range_service_address ? ` · ${escapeHtml(item.range_service_address)}` : ''}
+      </option>
+    `).join('')}`;
+    ipSelect.value = '';
+    document.getElementById('bmcnetWizardIpHint').textContent = availableIps.length
+      ? `Der er ${availableIps.length} ledige IP'er på den valgte hovedadresse.`
+      : 'Ingen ledige IP’er på den valgte hovedadresse lige nu.';
+  }
+
+  async function refreshBmcnetWizardAllocationMode() {
+    const ipProductId = Number(document.getElementById('bmcnetWizardIpProduct').value || 0) || null;
+    const isStaticIp = ipProductId ? isStaticWanIpProduct(ipProductId) : false;
+    document.getElementById('bmcnetWizardRangeWrap').classList.toggle('d-none', isStaticIp);
+    document.getElementById('bmcnetWizardIpWrap').classList.toggle('d-none', !isStaticIp);
+    if (isStaticIp) {
+      await refreshBmcnetWizardIpState(document.getElementById('bmcnetWizardSharedHeadSelect').value);
+    }
+  }
+
+  async function refreshBmcnetWizardHeadState(sharedHeadId) {
+    const headId = Number(sharedHeadId || 0);
+    const head = getSharedHeadOptions().find((item) => Number(item.id) === headId) || currentConnection;
+    const rangeSelect = document.getElementById('bmcnetWizardRangeSelect');
+    const hint = document.getElementById('bmcnetWizardRangeHint');
+    const headHint = document.getElementById('bmcnetWizardHeadHint');
+    const feedback = document.getElementById('bmcnetWizardFeedback');
+
+    if (headHint) {
+      headHint.textContent = head?.address
+        ? `${head.name || 'Hovedforbindelse'} · ${head.address}`
+        : (head?.name || 'Vælg hovedforbindelse');
+    }
+
+    const ranges = headId === Number(connectionId)
+      ? currentRanges
+      : await loadRangesForSharedHead(headId);
+    const availableRanges = filterAvailableBmcnetRanges(ranges);
+    rangeSelect.innerHTML = `<option value="">Ingen IP-range endnu</option>${availableRanges.map((range) => `
+      <option value="${range.id}">${range.cidr} · ${range.available_addresses || 0} ledige · ${range.service_address || head?.address || '-'}</option>
+    `).join('')}`;
+    hint.textContent = availableRanges.length
+      ? `Der er ${availableRanges.length} helt ledige ranges på den valgte hovedforbindelse.`
+      : 'Ingen helt ledige ranges på den valgte hovedforbindelse lige nu. Vælg en anden hovedforbindelse eller opret uden IP-range.';
+    if (feedback) feedback.textContent = '';
+    await refreshBmcnetWizardAllocationMode();
+  }
+
+  function populateBmcnetWizard(connection) {
+    document.getElementById('openBmcnetWizardBtn').classList.toggle('d-none', !connection?.is_shared_head);
+    if (!connection?.is_shared_head) return;
+
+    document.getElementById('bmcnetWizardCustomerLookup').value = '';
+    document.getElementById('bmcnetWizardCustomerId').value = '';
+    document.getElementById('bmcnetWizardName').value = '';
+    document.getElementById('bmcnetWizardService').value = '';
+    document.getElementById('bmcnetWizardAddress').value = connection.address || '';
+    document.getElementById('bmcnetWizardBillingInterval').value = 'monthly';
+    document.getElementById('bmcnetWizardBillingDay').value = '1';
+    document.getElementById('bmcnetWizardStartDate').value = new Date().toISOString().slice(0, 10);
+    document.getElementById('bmcnetWizardInternetProduct').value = '';
+    document.getElementById('bmcnetWizardIpProduct').value = '';
+    document.getElementById('bmcnetWizardInternetPrice').value = '';
+    document.getElementById('bmcnetWizardIpPrice').value = '';
+    document.getElementById('bmcnetWizardNotes').value = '';
+    document.getElementById('bmcnetWizardGatewayCheckbox').checked = false;
+    document.getElementById('bmcnetWizardFeedback').textContent = '';
+    const sharedHeadSelect = document.getElementById('bmcnetWizardSharedHeadSelect');
+    const sharedHeads = getSharedHeadOptions();
+    sharedHeadSelect.innerHTML = sharedHeads.map((head) => (
+      `<option value="${head.id}">${escapeHtml(head.name || '-')}${head.address ? ` · ${escapeHtml(head.address)}` : ''}</option>`
+    )).join('');
+    sharedHeadSelect.value = String(connection.id);
+    refreshBmcnetWizardHeadState(connection.id);
+  }
+
+  function openBmcnetWizard() {
+    if (!currentConnection?.is_shared_head) return;
+    populateBmcnetWizard(currentConnection);
+    if (!bmcnetWizardModal) {
+      bmcnetWizardModal = new bootstrap.Modal(document.getElementById('bmcnetWizardModal'));
+    }
+    bmcnetWizardModal.show();
+  }
+
+  function syncBmcnetWizardPrice(selectId, inputId) {
+    const select = document.getElementById(selectId);
+    const input = document.getElementById(inputId);
+    if (!select || !input) return;
+    const option = select.options[select.selectedIndex];
+    if (!option || !option.value) {
+      input.value = '';
+      return;
+    }
+    input.value = option.dataset.price || '';
+  }
+
+  async function createBmcnetConnection() {
+    const feedback = document.getElementById('bmcnetWizardFeedback');
+    const button = document.getElementById('bmcnetWizardSubmitBtn');
+    document.getElementById('bmcnetWizardCustomerId').value =
+      resolveLookupId(document.getElementById('bmcnetWizardCustomerLookup').value, customerOptions) || '';
+
+    const customerId = Number(document.getElementById('bmcnetWizardCustomerId').value || 0) || null;
+    const sharedHeadId = Number(document.getElementById('bmcnetWizardSharedHeadSelect').value || 0) || null;
+    const internetProductId = Number(document.getElementById('bmcnetWizardInternetProduct').value || 0) || null;
+    const ipProductId = Number(document.getElementById('bmcnetWizardIpProduct').value || 0) || null;
+    const useStaticWanIp = ipProductId ? isStaticWanIpProduct(ipProductId) : false;
+    const ipSelect = document.getElementById('bmcnetWizardIpSelect');
+    const selectedIpOption = ipSelect?.options?.[ipSelect.selectedIndex] || null;
+    const selectedIpId = useStaticWanIp ? (Number(ipSelect?.value || 0) || null) : null;
+    const selectedIpHeadId = useStaticWanIp ? (Number(selectedIpOption?.dataset?.headId || 0) || null) : null;
+    const payload = {
+      customer_id: customerId,
+      case_title: document.getElementById('bmcnetWizardName').value.trim() || null,
+      service_label: document.getElementById('bmcnetWizardService').value.trim() || null,
+      address: document.getElementById('bmcnetWizardAddress').value.trim() || null,
+      billing_interval: document.getElementById('bmcnetWizardBillingInterval').value || 'monthly',
+      billing_day: Number(document.getElementById('bmcnetWizardBillingDay').value || 1),
+      start_date: document.getElementById('bmcnetWizardStartDate').value,
+      internet_product_id: internetProductId,
+      internet_unit_price: document.getElementById('bmcnetWizardInternetPrice').value !== ''
+        ? Number(document.getElementById('bmcnetWizardInternetPrice').value)
+        : null,
+      ip_product_id: ipProductId,
+      ip_unit_price: document.getElementById('bmcnetWizardIpPrice').value !== ''
+        ? Number(document.getElementById('bmcnetWizardIpPrice').value)
+        : null,
+      notes: document.getElementById('bmcnetWizardNotes').value.trim() || null,
+      range_id: useStaticWanIp ? null : (Number(document.getElementById('bmcnetWizardRangeSelect').value || 0) || null),
+      ip_address_id: selectedIpId,
+      mark_gateway: useStaticWanIp ? Boolean(document.getElementById('bmcnetWizardGatewayCheckbox').checked) : false,
+    };
+
+    if (!sharedHeadId) {
+      feedback.textContent = 'Vælg en hovedforbindelse.';
+      return;
+    }
+    if (!payload.customer_id) {
+      feedback.textContent = 'Vælg en kunde.';
+      return;
+    }
+    if (!payload.internet_product_id) {
+      feedback.textContent = 'Vælg et internetprodukt.';
+      return;
+    }
+    if (!payload.start_date) {
+      feedback.textContent = 'Vælg en startdato.';
+      return;
+    }
+    if (payload.ip_product_id && useStaticWanIp && !payload.ip_address_id) {
+      feedback.textContent = 'Vælg en ledig IP-adresse til Statisk WAN IP.';
+      return;
+    }
+    if (payload.ip_product_id && useStaticWanIp && selectedIpHeadId !== sharedHeadId) {
+      feedback.textContent = 'Den valgte IP matcher ikke den valgte hovedforbindelse. Vælg IP igen.';
+      return;
+    }
+    if (payload.ip_product_id && !useStaticWanIp && !payload.range_id) {
+      feedback.textContent = 'Vælg et IP-range til IP-produktet.';
+      return;
+    }
+
+    feedback.textContent = 'Opretter sag, abonnement og BMCnet-forbindelse...';
+    if (button) button.disabled = true;
+    try {
+      const response = await fetch(`/api/v1/internet-connections/${sharedHeadId}/bmcnet-connections`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+      if (!response.ok) {
+        feedback.textContent = await extractErrorMessage(response, 'Kunne ikke oprette BMCnet-forbindelsen.');
+        return;
+      }
+      const created = await response.json();
+      feedback.innerHTML = created?.sag?.id
+        ? `Oprettet. <a href="/sag/${created.sag.id}/v3">Åbn sag #${created.sag.id}</a>`
+        : 'Oprettet.';
+      await loadConnection();
+      if (bmcnetWizardModal) bmcnetWizardModal.hide();
+    } catch (error) {
+      feedback.textContent = error?.message || 'Netværksfejl under oprettelse.';
+    } finally {
+      if (button) button.disabled = false;
+    }
+  }
+
+  async function loadConnection() {
+    await loadLookups();
+
+    const [
+      connectionResponse,
+      rangesResponse,
+      addressesResponse,
+      summaryResponse,
+      pricingResponse,
+      pricingHistoryResponse,
+      contractsResponse,
+      historyResponse,
+    ] = await Promise.all([
+      fetch(`/api/v1/internet-connections/${connectionId}`),
+      fetch(`/api/v1/internet-connections/${connectionId}/ip-ranges`),
+      fetch(`/api/v1/internet-connections/${connectionId}/ip-addresses`),
+      fetch(`/api/v1/internet-connections/${connectionId}/ip-addresses/summary`),
+      fetch(`/api/v1/internet-connections/${connectionId}/pricing`),
+      fetch(`/api/v1/internet-connections/${connectionId}/pricing/history`),
+      fetch('/api/v1/internet-connections/contracts'),
+      fetch(`/api/v1/internet-connections/${connectionId}/history`),
+    ]);
+
+    if (!connectionResponse.ok) {
+      document.getElementById('detailName').textContent = 'Forbindelse ikke fundet';
+      document.getElementById('detailSubtitle').textContent = 'Den ønskede forbindelse findes ikke.';
+      return;
+    }
+
+    const connection = await connectionResponse.json();
+    const ranges = await rangesResponse.json();
+    const addresses = await addressesResponse.json();
+    const summary = await summaryResponse.json();
+    const pricing = await pricingResponse.json();
+    const pricingHistory = await pricingHistoryResponse.json();
+    const contracts = await contractsResponse.json();
+    const history = await historyResponse.json();
+
+    currentConnection = connection;
+    currentAddresses = Array.isArray(addresses) ? addresses : [];
+    currentRanges = Array.isArray(ranges) ? ranges : [];
+    currentBmcnetChildren = connection.is_shared_head
+      ? await safeJson(await fetch(`/api/v1/internet-connections/${connectionId}/children?bmcnet_only=true`), [])
+      : [];
+
+    renderCore(connection, pricing, summary);
+    renderRanges(currentRanges);
+    renderAddresses(currentAddresses);
+    renderPricing(pricing, pricingHistory);
+    renderHistory(history);
+    renderRelationGrid(connection);
+    renderBmcnetChildren(connection, currentBmcnetChildren);
+    renderContractsOverview(contracts);
+  }
+
+  function renderCore(connection, pricing, summary) {
+    document.getElementById('detailName').textContent = connection.name || 'Unavngiven forbindelse';
+    const ownerText = connection.customer_name || 'Ingen kunde koblet på';
+    const businessText = connection.allocation_model === 'shared'
+      ? `Ejer: ${ownerText} · kunder fordeles på ranges/IP'er`
+      : ownerText;
+    const ownSales = Number(pricing.sales_price || 0);
+    const ownPurchase = Number(pricing.monthly_cost || 0);
+    const bmcnetSales = connection.is_shared_head ? Number(connection.bmcnet_child_sales_price || 0) : 0;
+    const bmcnetPurchase = connection.is_shared_head ? Number(connection.bmcnet_child_monthly_cost || 0) : 0;
+    const effectiveSales = ownSales + bmcnetSales;
+    const effectivePurchase = ownPurchase + bmcnetPurchase;
+    const effectiveMargin = effectiveSales - effectivePurchase;
+    const childConnections = Array.isArray(currentBmcnetChildren) ? currentBmcnetChildren : [];
+    const totalDown = Number(connection.download_mbps || 0);
+    const totalUp = Number(connection.upload_mbps || 0);
+    const usedDown = childConnections.reduce((sum, child) => sum + Number(child.download_mbps || child.speed_mbps || 0), 0);
+    const usedUp = childConnections.reduce((sum, child) => sum + Number(child.upload_mbps || child.speed_mbps || 0), 0);
+    const downPct = totalDown > 0 ? Math.round((usedDown / totalDown) * 100) : 0;
+    const upPct = totalUp > 0 ? Math.round((usedUp / totalUp) * 100) : 0;
+    document.getElementById('detailSubtitle').textContent = `${connection.provider || 'Ingen leverandør'} · ${businessText}`;
+    document.getElementById('metricSales').textContent = formatDKK(effectiveSales);
+    document.getElementById('metricPurchase').textContent = formatDKK(effectivePurchase);
+    document.getElementById('metricMargin').textContent = formatDKK(effectiveMargin);
+    document.getElementById('metricIps').textContent = String((summary.in_use || 0) + (summary.reserved || 0));
+    document.getElementById('metricBandwidth').textContent = `${usedDown} / ${totalDown || 0} Mbps`;
+    document.getElementById('metricBandwidthSub').textContent = totalUp
+      ? `Upload ${usedUp} / ${totalUp} Mbps · ${downPct}% ned / ${upPct}% op`
+      : `${downPct}%`;
+    document.getElementById('ipAddressSummary').innerHTML = `Tilgængelige: <strong>${summary.available || 0}</strong> · Reserverede: <strong>${summary.reserved || 0}</strong> · I brug: <strong>${summary.in_use || 0}</strong>`;
+
+    const contractText = connection.contract_start || connection.contract_end
+      ? `${formatDate(connection.contract_start)} → ${formatDate(connection.contract_end)}`
+      : '-';
+    const subscriptionText = connection.subscription_number
+      ? `${connection.subscription_number} · ${connection.subscription_product_name || '-'}`
+      : (connection.value_label || '-');
+    const monitoringText = connection.monitoring_url
+      ? `<a href="${escapeHtml(connection.monitoring_url)}" target="_blank" rel="noopener noreferrer">${escapeHtml(connection.monitoring_url)}</a>`
+      : '<span class="detail-read-muted">-</span>';
+
+    document.getElementById('coreReadView').innerHTML = `
+      <div class="detail-read-strip">
+        <div class="detail-read-chip"><span class="label">Leverandør</span><span class="value">${connection.provider || '-'}</span></div>
+        <div class="detail-read-chip"><span class="label">Kredsløb</span><span class="value">${connection.circuit_number || '-'}</span></div>
+        <div class="detail-read-chip"><span class="label">Binding</span><span class="value">${connection.allocation_model_label || '-'} · ${connection.value_type_label || '-'}</span></div>
+        <div class="detail-read-chip"><span class="label">Type</span><span class="value">${connection.connection_type || '-'}</span></div>
+        <div class="detail-read-chip"><span class="label">Teknologi</span><span class="value">${connection.technology || '-'}</span></div>
+        <div class="detail-read-chip"><span class="label">Hastighed</span><span class="value">${connection.download_mbps || 0}/${connection.upload_mbps || 0} Mbps</span></div>
+      </div>
+      <div class="detail-read-grid">
+        <div class="detail-read-row full"><span class="label">Navn</span><div class="value">${connection.name || '-'}</div></div>
+        <div class="detail-read-row full"><span class="label">Adresse</span><div class="value">${connection.address || '-'}</div></div>
+        <div class="detail-read-row"><span class="label">Kunde</span><div class="value">${connection.customer_name || '-'}</div></div>
+        <div class="detail-read-row"><span class="label">Parent</span><div class="value">${connection.parent_name || '-'}</div></div>
+        <div class="detail-read-row"><span class="label">Abonnement</span><div class="value">${subscriptionText}</div></div>
+        <div class="detail-read-row"><span class="label">Kontrakt</span><div class="value">${contractText}</div></div>
+        <div class="detail-read-row"><span class="label">Fallback</span><div class="value">${connection.speed_mbps || 0} Mbps</div></div>
+        <div class="detail-read-row"><span class="label">Overvågning</span><div class="value">${monitoringText}</div></div>
+        <div class="detail-read-row full"><span class="label">Noter</span><div class="value">${connection.notes || '<span class="detail-read-muted">-</span>'}</div></div>
+      </div>
+    `;
+
+    setStatusBadge(connection.status);
+
+    document.getElementById('fieldName').value = connection.name || '';
+    document.getElementById('fieldProvider').value = connection.provider || '';
+    document.getElementById('fieldCircuit').value = connection.circuit_number || '';
+    document.getElementById('fieldAddress').value = connection.address || '';
+    setLookupValue('fieldCustomerLookup', 'fieldCustomerId', customerOptions, connection.customer_id);
+    setLookupValue('fieldParentLookup', 'fieldParentId', connectionOptions, connection.parent_id);
+    document.getElementById('fieldConnectionType').value = connection.connection_type || '';
+    document.getElementById('fieldTechnology').value = connection.technology || '';
+    document.getElementById('fieldDownload').value = connection.download_mbps || '';
+    document.getElementById('fieldUpload').value = connection.upload_mbps || '';
+    document.getElementById('fieldSpeed').value = connection.speed_mbps || '';
+    document.getElementById('fieldStatus').value = connection.status || 'active';
+    document.getElementById('fieldMonitoringUrl').value = connection.monitoring_url || '';
+    document.getElementById('fieldAllocationModel').value = connection.allocation_model || 'dedicated';
+    document.getElementById('fieldValueType').value = connection.value_type || 'other';
+    document.getElementById('fieldValueLabel').value = connection.value_label || '';
+    setSubscriptionValue(connection.subscription_id);
+    document.getElementById('fieldContractStart').value = connection.contract_start || '';
+    document.getElementById('fieldContractEnd').value = connection.contract_end || '';
+    document.getElementById('fieldNotes').value = connection.notes || '';
+    toggleValueFields();
+    toggleCoreEdit(false, true);
+  }
+
+  function toggleCoreEdit(force, silent = false) {
+    coreEditMode = Boolean(force);
+    document.getElementById('coreReadView').classList.toggle('d-none', coreEditMode);
+    document.getElementById('coreEditForm').classList.toggle('d-none', !coreEditMode);
+    document.getElementById('editCoreDetailsBtn').classList.toggle('d-none', coreEditMode);
+    document.getElementById('cancelCoreDetailsBtn').classList.toggle('d-none', !coreEditMode);
+    document.getElementById('saveCoreDetailsBtn').classList.toggle('d-none', !coreEditMode);
+    if (!silent) {
+      document.getElementById('detailSaveFeedback').textContent = coreEditMode ? 'Redigering aktiv.' : '';
+    }
+  }
+
+  function renderRanges(ranges) {
+    const list = document.getElementById('ipRangesList');
+    const rangeSelect = document.getElementById('addressRangeSelect');
+    const visibleRanges = ranges.filter((range) => range.belongs_to_connection !== false);
+    const mismatchedRanges = ranges.filter((range) => range.belongs_to_connection === false);
+
+    if (!visibleRanges.length && !mismatchedRanges.length) {
+      list.innerHTML = '<div class="text-muted">Ingen IP-ranges registreret endnu.</div>';
+      rangeSelect.innerHTML = '<option value="">Ingen ranges</option>';
+      return;
+    }
+
+    const visibleMarkup = visibleRanges.map((range) => `
+      <div class="detail-grid-card" id="rangeCard-${range.id}">
+        <span class="label">${range.name || 'Range'}</span>
+        <div class="value">${range.cidr || '-'}</div>
+        <div class="small text-muted mt-2">Brugbare: ${range.usable_hosts || 0} · Brugt: ${range.used_addresses || 0} · Ledige: ${range.available_addresses || 0}</div>
+        ${range.customer_name ? `<div class="small text-muted mt-1">Kunde: ${range.customer_name}</div>` : ''}
+        ${range.provider_reference ? `<div class="small text-muted mt-1">Ref: ${range.provider_reference}</div>` : ''}
+        ${range.contract_number ? `<div class="small text-muted mt-1">Kontrakt: ${range.contract_number}</div>` : ''}
+        ${range.service_address ? `<div class="small text-muted mt-1">${range.service_address}</div>` : ''}
+        ${(Number(range.monthly_cost || 0) || Number(range.sales_price || 0)) ? `<div class="small text-muted mt-1">Kost ${formatDKK(range.monthly_cost || 0)} · Salg ${formatDKK(range.sales_price || 0)}</div>` : ''}
+        ${range.description ? `<div class="small text-muted mt-1">${range.description}</div>` : ''}
+        <div class="mt-3 d-flex gap-2">
+          <button class="btn btn-sm btn-outline-primary" type="button" onclick="toggleRangeEdit(${range.id}, true)">Rediger</button>
+        </div>
+        <div class="small text-muted mt-2" id="rangeFeedback-${range.id}"></div>
+        <div class="d-none" id="rangeEdit-${range.id}">
+          <div class="range-edit-grid">
+            <div>
+              <label class="form-label small text-muted mb-1">Navn</label>
+              <input type="text" class="form-control form-control-sm" id="rangeEditName-${range.id}" value="${escapeHtml(range.name || '')}">
+            </div>
+            <div>
+              <label class="form-label small text-muted mb-1">CIDR</label>
+              <input type="text" class="form-control form-control-sm" value="${escapeHtml(range.cidr || '')}" disabled>
+            </div>
+            <div>
+              <label class="form-label small text-muted mb-1">Provider ref.</label>
+              <input type="text" class="form-control form-control-sm" id="rangeEditProviderRef-${range.id}" value="${escapeHtml(range.provider_reference || '')}">
+            </div>
+            <div>
+              <label class="form-label small text-muted mb-1">Kontrakt</label>
+              <input type="text" class="form-control form-control-sm" id="rangeEditContract-${range.id}" value="${escapeHtml(range.contract_number || '')}">
+            </div>
+            <div>
+              <label class="form-label small text-muted mb-1">Serviceadresse</label>
+              <input type="text" class="form-control form-control-sm" id="rangeEditServiceAddress-${range.id}" value="${escapeHtml(range.service_address || '')}">
+            </div>
+            <div>
+              <label class="form-label small text-muted mb-1">Kunde på range</label>
+              <input type="text" class="form-control form-control-sm" id="rangeEditCustomer-${range.id}" value="${range.customer_name ? `${range.customer_id} · ${escapeHtml(range.customer_name)}` : ''}" list="customerLookupList" placeholder="Kunde">
+              <input type="hidden" id="rangeEditCustomerId-${range.id}" value="${range.customer_id || ''}">
+            </div>
+            <div>
+              <label class="form-label small text-muted mb-1">Kost</label>
+              <input type="number" class="form-control form-control-sm" id="rangeEditCost-${range.id}" value="${Number(range.monthly_cost || 0)}">
+            </div>
+            <div>
+              <label class="form-label small text-muted mb-1">Salg</label>
+              <input type="number" class="form-control form-control-sm" id="rangeEditSales-${range.id}" value="${Number(range.sales_price || 0)}">
+            </div>
+            <div style="grid-column: 1 / -1;">
+              <label class="form-label small text-muted mb-1">Beskrivelse</label>
+              <input type="text" class="form-control form-control-sm" id="rangeEditDescription-${range.id}" value="${escapeHtml(range.description || '')}">
+            </div>
+          </div>
+          <div class="mt-3 d-flex gap-2">
+            <button class="btn btn-sm btn-primary" type="button" onclick="saveRange(${range.id})">Gem range</button>
+            <button class="btn btn-sm btn-outline-secondary" type="button" onclick="toggleRangeEdit(${range.id}, false)">Annuller</button>
+          </div>
+        </div>
+      </div>
+    `).join('');
+
+    const mismatchMarkup = mismatchedRanges.length ? `
+      <div class="detail-grid-card" style="grid-column: 1 / -1; border-color: #f3c2c2; background: #fff8f8;">
+        <span class="label text-danger">Afvigelser</span>
+        <div class="small text-muted mb-2">Disse ranges matcher ikke forbindelsens adresse eller kunde og bør kontrolleres.</div>
+        ${mismatchedRanges.map((range) => `
+          <div class="small mb-2">
+            <strong>${range.cidr}</strong> · ${range.customer_name || 'Ingen kunde'}<br>
+            <span class="text-danger">${range.alignment_warning || 'Matcher ikke forbindelsen'}</span>
+          </div>
+        `).join('')}
+      </div>
+    ` : '';
+
+    list.innerHTML = visibleMarkup + mismatchMarkup;
+
+    rangeSelect.innerHTML = visibleRanges.length
+      ? visibleRanges.map((range) => `<option value="${range.id}">${range.name} (${range.cidr})</option>`).join('')
+      : '<option value="">Ingen matchende ranges</option>';
+  }
+
+  function toggleRangeEdit(rangeId, open) {
+    const panel = document.getElementById(`rangeEdit-${rangeId}`);
+    const card = document.getElementById(`rangeCard-${rangeId}`);
+    if (panel) panel.classList.toggle('d-none', !open);
+    if (card) card.classList.toggle('editing', !!open);
+  }
+
+  async function saveRange(rangeId) {
+    const feedback = document.getElementById(`rangeFeedback-${rangeId}`);
+    const customerValue = document.getElementById(`rangeEditCustomer-${rangeId}`).value;
+    const customerId = resolveLookupId(customerValue, customerOptions);
+    document.getElementById(`rangeEditCustomerId-${rangeId}`).value = customerId || '';
+    const payload = {
+      name: document.getElementById(`rangeEditName-${rangeId}`).value.trim() || null,
+      provider_reference: document.getElementById(`rangeEditProviderRef-${rangeId}`).value.trim() || null,
+      contract_number: document.getElementById(`rangeEditContract-${rangeId}`).value.trim() || null,
+      service_address: document.getElementById(`rangeEditServiceAddress-${rangeId}`).value.trim() || null,
+      customer_id: Number(document.getElementById(`rangeEditCustomerId-${rangeId}`).value || 0) || null,
+      monthly_cost: Number(document.getElementById(`rangeEditCost-${rangeId}`).value || 0),
+      sales_price: Number(document.getElementById(`rangeEditSales-${rangeId}`).value || 0),
+      description: document.getElementById(`rangeEditDescription-${rangeId}`).value.trim() || null,
+    };
+
+    if (!payload.name) {
+      feedback.textContent = 'Navn er påkrævet.';
+      return;
+    }
+
+    feedback.textContent = 'Gemmer range...';
+    try {
+      const response = await fetch(`/api/v1/internet-connections/${connectionId}/ip-ranges/${rangeId}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+      if (!response.ok) {
+        feedback.textContent = await extractErrorMessage(response, 'Kunne ikke gemme IP-range.');
+        return;
+      }
+      feedback.textContent = 'IP-range gemt.';
+      toggleRangeEdit(rangeId, false);
+      await loadConnection();
+    } catch (error) {
+      feedback.textContent = error?.message || 'Netværksfejl under gem af IP-range.';
+    }
+  }
+
+  function renderAddresses(addresses) {
+    const search = document.getElementById('addressSearchInput').value.trim().toLowerCase();
+    const statusFilter = document.getElementById('addressStatusFilter').value;
+    const body = document.getElementById('ipAddressesTableBody');
+
+    const filtered = addresses.filter((address) => {
+      if (address.belongs_to_connection === false) return false;
+      const haystack = `${address.ip_address || ''} ${address.assigned_to || ''} ${address.assigned_type || ''} ${address.assigned_customer_name || ''} ${address.assigned_connection_name || ''} ${address.comment || ''}`.toLowerCase();
+      const searchOk = !search || haystack.includes(search);
+      const statusOk = !statusFilter || address.status === statusFilter;
+      return searchOk && statusOk;
+    });
+
+    if (!filtered.length) {
+      body.innerHTML = '<tr><td colspan="5" class="text-muted py-4">Ingen IP-adresser matcher filtrene.</td></tr>';
+      return;
+    }
+
+    body.innerHTML = filtered.map((address) => {
+      const isEditing = editingAddressId === address.id;
+      const companyName = address.assigned_customer_name || address.range_customer_name || '-';
+      const roleLabel = address.assigned_type ? formatIpRole(address.assigned_type) : '';
+      const serviceName = address.assigned_to || '-';
+      const subscriptionLink = Number(address.assigned_subscription_sag_id || 0) > 0
+        ? `/sag/${address.assigned_subscription_sag_id}/v3`
+        : '';
+      const subscriptionTitle = address.assigned_subscription_number || address.assigned_to || '';
+      return `
+        <tr>
+          <td><strong>${address.ip_address || '-'}</strong></td>
+          <td><span class="internet-status ${address.status || 'available'}">${address.status_label || address.status || '-'}</span></td>
+          <td>
+            ${subscriptionLink
+              ? `<a href="${subscriptionLink}" class="d-inline-flex align-items-center gap-2 text-decoration-none" title="${subscriptionTitle}">
+                   <input type="checkbox" checked onclick="window.location.href='${subscriptionLink}'; return false;">
+                   <span>${subscriptionTitle}</span>
+                 </a>`
+              : '<input type="checkbox" disabled>'}
+          </td>
+          <td>
+            <div>${companyName}</div>
+            <div class="small text-muted">
+              ${roleLabel ? `${roleLabel} · ` : ''}${serviceName}
+            </div>
+          </td>
+          <td class="text-end">
+            <button class="btn btn-sm btn-outline-primary" type="button" onclick="toggleAddressEdit(${address.id})" title="Rediger IP">
+              <i class="bi ${isEditing ? 'bi-x-lg' : 'bi-pencil'}"></i>
+            </button>
+          </td>
+        </tr>
+        ${isEditing ? `
+        <tr class="bg-light">
+          <td colspan="5">
+            <div class="row g-2 py-2">
+              <div class="col-md-2">
+                <select class="form-select form-select-sm" id="addressStatus-${address.id}">
+                  <option value="available" ${address.status === 'available' ? 'selected' : ''}>Tilgængelig</option>
+                  <option value="reserved" ${address.status === 'reserved' ? 'selected' : ''}>Reserveret</option>
+                  <option value="in_use" ${address.status === 'in_use' ? 'selected' : ''}>I brug</option>
+                </select>
+              </div>
+              <div class="col-md-2">
+                <select class="form-select form-select-sm" id="addressRole-${address.id}">
+                  <option value="" ${!address.assigned_type ? 'selected' : ''}>Ingen rolle</option>
+                  <option value="bmcnet_gateway" ${address.assigned_type === 'bmcnet_gateway' ? 'selected' : ''}>BMCnet gateway</option>
+                  <option value="webserver" ${address.assigned_type === 'webserver' ? 'selected' : ''}>Webserver</option>
+                  <option value="mailserver" ${address.assigned_type === 'mailserver' ? 'selected' : ''}>Mailserver</option>
+                  <option value="unifi" ${address.assigned_type === 'unifi' ? 'selected' : ''}>Unifi</option>
+                  <option value="firewall" ${address.assigned_type === 'firewall' ? 'selected' : ''}>Firewall</option>
+                  <option value="vpn" ${address.assigned_type === 'vpn' ? 'selected' : ''}>VPN</option>
+                  <option value="service" ${address.assigned_type === 'service' ? 'selected' : ''}>Anden service</option>
+                </select>
+              </div>
+              <div class="col-md-3"><input type="text" class="form-control form-control-sm" id="addressService-${address.id}" value="${address.assigned_to || ''}" placeholder="Service/navn"></div>
+              <div class="col-md-3">
+                <input type="text" class="form-control form-control-sm" id="addressAssignedCustomer-${address.id}" value="${address.assigned_customer_name ? `${address.assigned_customer_id} · ${address.assigned_customer_name}` : ''}" list="customerLookupList" placeholder="Kunde">
+                <input type="hidden" id="addressAssignedCustomerId-${address.id}" value="${address.assigned_customer_id || ''}">
+              </div>
+              <div class="col-md-3"><input type="text" class="form-control form-control-sm" id="addressComment-${address.id}" value="${address.comment || ''}" placeholder="Kommentar"></div>
+              <div class="col-md-auto d-flex justify-content-end">
+                <button class="btn btn-sm btn-primary" type="button" onclick="updateAddress(${address.id})">Gem ændringer</button>
+              </div>
+            </div>
+          </td>
+        </tr>` : ''}
+      `;
+    }).join('');
+  }
+
+  function toggleAddressEdit(addressId) {
+    editingAddressId = editingAddressId === addressId ? null : addressId;
+    renderAddresses(currentAddresses);
+  }
+
+  function renderPricing(pricing, pricingHistory) {
+    document.getElementById('pricingSummaryGrid').innerHTML = `
+      <div class="detail-grid-card">
+        <span class="label">Aktuel kost</span>
+        <div class="value">${formatDKK(pricing.monthly_cost || 0)}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Aktuelt salg</span>
+        <div class="value">${formatDKK(pricing.sales_price || 0)}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Kontraktstatus</span>
+        <div class="value">${pricing.contract_status || 'ukendt'}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Periode</span>
+        <div class="value">${formatDate(pricing.contract_start)} → ${formatDate(pricing.contract_end)}</div>
+      </div>
+    `;
+
+    const list = document.getElementById('pricingHistoryList');
+    if (!pricingHistory.length) {
+      list.innerHTML = '<div class="text-muted">Ingen prishistorik endnu.</div>';
+      return;
+    }
+
+    list.innerHTML = pricingHistory.map((entry) => `
+      <div class="timeline-item">
+        <div class="fw-semibold">${formatDate(entry.effective_from)}</div>
+        <div class="small text-muted">${entry.notes || 'Ingen note'}</div>
+        <div class="small mt-1">Kost ${formatDKK(entry.purchase_price || 0)} · Salg ${formatDKK(entry.sales_price || 0)}</div>
+      </div>
+    `).join('');
+  }
+
+  function renderHistory(history) {
+    const list = document.getElementById('historyList');
+    if (!history.length) {
+      list.innerHTML = '<div class="text-muted">Ingen historik registreret endnu.</div>';
+      return;
+    }
+
+    list.innerHTML = history.map((entry) => `
+      <div class="timeline-item">
+        <div class="fw-semibold">${entry.summary || entry.event_type || '-'}</div>
+        <div class="small text-muted">${formatDateTime(entry.created_at)}</div>
+        ${renderHistoryDetails(entry)}
+      </div>
+    `).join('');
+  }
+
+  function renderRelationGrid(connection) {
+    document.getElementById('relationGrid').innerHTML = `
+      <div class="detail-grid-card">
+        <span class="label">Kunde</span>
+        <div class="value">${connection.customer_name || '-'}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Forretningsbinding</span>
+        <div class="value">${connection.allocation_model_label || '-'} · ${connection.value_type_label || '-'}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Parent</span>
+        <div class="value">${connection.parent_name || '-'}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Kunde-ID</span>
+        <div class="value">${connection.customer_id || '-'}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Range / IP</span>
+        <div class="value">${connection.ip_range_count || 0} / ${connection.total_ip_addresses || 0}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Overvågning</span>
+        <div class="value">${connection.monitoring_url ? `<a href="${connection.monitoring_url}" target="_blank">Åbn</a>` : '-'}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Abonnement</span>
+        <div class="value">${connection.subscription_number ? `${connection.subscription_number} · ${connection.subscription_product_name || '-'}` : (connection.value_label || '-')}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">BMCnet underforbindelser</span>
+        <div class="value">${connection.is_shared_head ? Number(connection.bmcnet_child_count || 0) : '-'}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Opdateret</span>
+        <div class="value">${formatDate(connection.updated_at)}</div>
+      </div>
+    `;
+  }
+
+  function renderContractsOverview(contracts) {
+    const list = document.getElementById('contractsOverviewList');
+    if (!Array.isArray(contracts) || !contracts.length) {
+      list.innerHTML = '<div class="text-muted">Ingen kontrakter fundet.</div>';
+      return;
+    }
+
+    list.innerHTML = contracts.slice(0, 8).map((contract) => `
+      <div class="timeline-item">
+        <div class="fw-semibold">${contract.name || '-'}</div>
+        <div class="small text-muted">${contract.provider || '-'} · ${formatDate(contract.contract_end)}</div>
+      </div>
+    `).join('');
+  }
+
+  function renderBmcnetChildren(connection, children) {
+    const panel = document.getElementById('bmcnetChildrenPanel');
+    const countEl = document.getElementById('bmcnetChildrenCount');
+    const summaryGrid = document.getElementById('bmcnetChildrenSummaryGrid');
+    const list = document.getElementById('bmcnetChildrenList');
+
+    if (!connection.is_shared_head) {
+      panel.classList.add('d-none');
+      return;
+    }
+
+    panel.classList.remove('d-none');
+    const summary = connection.bmcnet_summary || {};
+    countEl.textContent = `${Number(summary.connection_count || 0)} kunder`;
+    summaryGrid.innerHTML = `
+      <div class="detail-grid-card">
+        <span class="label">BMCnet kunder</span>
+        <div class="value">${Number(summary.connection_count || 0)}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Aktive</span>
+        <div class="value">${Number(summary.active_connection_count || 0)}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">Salg</span>
+        <div class="value">${formatDKK(summary.sales_price || 0)}</div>
+      </div>
+      <div class="detail-grid-card">
+        <span class="label">IP i brug</span>
+        <div class="value">${Number(summary.ip_in_use_count || 0)}</div>
+      </div>
+    `;
+
+    if (!children.length) {
+      list.innerHTML = '<div class="text-muted">Ingen BMCnet-kunder på denne hovedforbindelse endnu.</div>';
+      return;
+    }
+
+    list.innerHTML = children.map((child) => `
+      <div class="timeline-item">
+        <div class="d-flex justify-content-between gap-2">
+          <div>
+            <div class="fw-semibold">${child.customer_name || child.name || 'Ukendt kunde'}</div>
+            <div class="small text-muted">${child.name || '-'} · ${child.subscription_number || 'Intet abonnement'} · ${formatSpeed(child)}</div>
+            <div class="small text-muted">${child.address || '-'}</div>
+          </div>
+          <div class="text-end">
+            <div class="fw-semibold">${formatDKK(child.sales_price || 0)}</div>
+            <div class="small text-muted">IP i brug ${Number(child.in_use_ip_addresses || 0)} / ${Number(child.total_ip_addresses || 0)}</div>
+            <a href="/economy/internet-connections/${child.id}" class="small">Åbn</a>
+          </div>
+        </div>
+      </div>
+    `).join('');
+  }
+
+  async function saveCoreDetails() {
+    const feedback = document.getElementById('detailSaveFeedback');
+    const saveButton = document.getElementById('saveCoreDetailsBtn');
+    document.getElementById('fieldCustomerId').value = resolveLookupId(document.getElementById('fieldCustomerLookup').value, customerOptions) || '';
+    document.getElementById('fieldParentId').value = resolveLookupId(document.getElementById('fieldParentLookup').value, connectionOptions) || '';
+    document.getElementById('fieldSubscriptionId').value = resolveSubscriptionId(document.getElementById('fieldSubscriptionLookup').value) || '';
+    const payload = {
+      name: document.getElementById('fieldName').value.trim(),
+      provider: document.getElementById('fieldProvider').value.trim() || null,
+      circuit_number: document.getElementById('fieldCircuit').value.trim() || null,
+      address: document.getElementById('fieldAddress').value.trim() || null,
+      customer_id: Number(document.getElementById('fieldCustomerId').value || 0) || null,
+      parent_id: Number(document.getElementById('fieldParentId').value || 0) || null,
+      connection_type: document.getElementById('fieldConnectionType').value.trim() || null,
+      technology: document.getElementById('fieldTechnology').value.trim() || null,
+      download_mbps: Number(document.getElementById('fieldDownload').value || 0) || null,
+      upload_mbps: Number(document.getElementById('fieldUpload').value || 0) || null,
+      speed_mbps: Number(document.getElementById('fieldSpeed').value || 0) || null,
+      status: document.getElementById('fieldStatus').value || 'active',
+      monitoring_url: document.getElementById('fieldMonitoringUrl').value.trim() || null,
+      allocation_model: document.getElementById('fieldAllocationModel').value || 'dedicated',
+      value_type: document.getElementById('fieldValueType').value || 'other',
+      value_label: document.getElementById('fieldValueLabel').value.trim() || null,
+      subscription_id: Number(document.getElementById('fieldSubscriptionId').value || 0) || null,
+      contract_start: document.getElementById('fieldContractStart').value || null,
+      contract_end: document.getElementById('fieldContractEnd').value || null,
+      notes: document.getElementById('fieldNotes').value.trim() || null,
+    };
+
+    if (!payload.name) {
+      feedback.textContent = 'Navn er påkrævet.';
+      return;
+    }
+    if (!payload.address) {
+      feedback.textContent = 'Adresse er påkrævet.';
+      return;
+    }
+    if (payload.value_type === 'subscription' && !payload.subscription_id) {
+      feedback.textContent = 'Vælg et gyldigt abonnement.';
+      return;
+    }
+
+    feedback.textContent = 'Gemmer...';
+    if (saveButton) saveButton.disabled = true;
+    try {
+      const response = await fetch(`/api/v1/internet-connections/${connectionId}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        feedback.textContent = await extractErrorMessage(response, 'Kunne ikke gemme forbindelsen.');
+        return;
+      }
+      feedback.textContent = 'Forbindelse gemt.';
+      coreEditMode = false;
+      await loadConnection();
+    } catch (error) {
+      feedback.textContent = error?.message || 'Netværksfejl under gem.';
+    } finally {
+      if (saveButton) saveButton.disabled = false;
+    }
+  }
+
+  function toggleValueFields() {
+    const valueType = document.getElementById('fieldValueType').value;
+    document.getElementById('fieldValueLabelWrap').classList.toggle('d-none', valueType !== 'other');
+    document.getElementById('fieldSubscriptionWrap').classList.toggle('d-none', valueType !== 'subscription');
+  }
+
+  async function createRange() {
+    const feedback = document.getElementById('rangeCreateFeedback');
+    const button = document.getElementById('createRangeButton');
+    const cidrValue = document.getElementById('rangeCidrInput').value.trim();
+    const nameValue = document.getElementById('rangeNameInput').value.trim();
+    const payload = {
+      name: nameValue || cidrValue,
+      cidr: cidrValue,
+      description: document.getElementById('rangeDescriptionInput').value.trim() || null,
+      provider_reference: document.getElementById('rangeProviderReferenceInput').value.trim() || null,
+      contract_number: document.getElementById('rangeContractInput').value.trim() || null,
+      customer_id: Number(document.getElementById('rangeCustomerIdInput').value || 0) || null,
+      service_address: document.getElementById('rangeServiceAddressInput').value.trim() || null,
+      monthly_cost: Number(document.getElementById('rangeMonthlyCostInput').value || 0),
+      sales_price: Number(document.getElementById('rangeSalesPriceInput').value || 0),
+    };
+    if (!payload.cidr) {
+      feedback.textContent = 'CIDR er påkrævet.';
+      return;
+    }
+    feedback.textContent = 'Gemmer range...';
+    if (button) button.disabled = true;
+    try {
+      const response = await fetch(`/api/v1/internet-connections/${connectionId}/ip-ranges`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+      if (!response.ok) {
+        feedback.textContent = await extractErrorMessage(response, 'Kunne ikke oprette IP-range.');
+        return;
+      }
+      document.getElementById('rangeNameInput').value = '';
+      document.getElementById('rangeCidrInput').value = '';
+      document.getElementById('rangeDescriptionInput').value = '';
+      document.getElementById('rangeProviderReferenceInput').value = '';
+      document.getElementById('rangeContractInput').value = '';
+      document.getElementById('rangeCustomerLookupInput').value = '';
+      document.getElementById('rangeCustomerIdInput').value = '';
+      document.getElementById('rangeServiceAddressInput').value = '';
+      document.getElementById('rangeMonthlyCostInput').value = '';
+      document.getElementById('rangeSalesPriceInput').value = '';
+      feedback.textContent = 'IP-range oprettet.';
+      await loadConnection();
+    } catch (error) {
+      feedback.textContent = error?.message || 'Netværksfejl under oprettelse af IP-range.';
+    } finally {
+      if (button) button.disabled = false;
+    }
+  }
+
+  window.createRange = createRange;
+
+  async function createAddress() {
+    const payload = {
+      range_id: Number(document.getElementById('addressRangeSelect').value || 0),
+      ip_address: document.getElementById('addressIpInput').value.trim(),
+      status: document.getElementById('addressStatusInput').value || 'available',
+      assigned_to: document.getElementById('addressAssignedInput').value.trim() || null,
+      assigned_customer_id: Number(document.getElementById('addressAssignedCustomerIdInput').value || 0) || null,
+      assigned_connection_id: Number(document.getElementById('addressAssignedConnectionIdInput').value || 0) || null,
+    };
+    if (!payload.range_id || !payload.ip_address) {
+      alert('Range og IP-adresse er påkrævet');
+      return;
+    }
+
+    const response = await fetch(`/api/v1/internet-connections/${connectionId}/ip-addresses`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+      alert('Kunne ikke oprette IP-adresse');
+      return;
+    }
+    document.getElementById('addressIpInput').value = '';
+    document.getElementById('addressAssignedInput').value = '';
+    document.getElementById('addressAssignedCustomerInput').value = '';
+    document.getElementById('addressAssignedCustomerIdInput').value = '';
+    document.getElementById('addressAssignedConnectionInput').value = '';
+    document.getElementById('addressAssignedConnectionIdInput').value = '';
+    await loadConnection();
+  }
+
+  async function updateAddress(addressId) {
+    document.getElementById(`addressAssignedCustomerId-${addressId}`).value =
+      resolveLookupId(document.getElementById(`addressAssignedCustomer-${addressId}`).value, customerOptions) || '';
+    const currentAddress = (currentAddresses || []).find((item) => Number(item.id) === Number(addressId));
+    const serviceValue = document.getElementById(`addressService-${addressId}`).value.trim() || null;
+    let roleValue = document.getElementById(`addressRole-${addressId}`).value || null;
+    let normalizedServiceValue = serviceValue;
+    if (roleValue === 'bmcnet_gateway' && !normalizedServiceValue) {
+      normalizedServiceValue = 'BMCnet kunde gateway';
+    }
+    if (!roleValue && normalizedServiceValue) {
+      roleValue = 'service';
+    }
+
+    const payload = {
+      status: document.getElementById(`addressStatus-${addressId}`).value,
+      assigned_to: normalizedServiceValue,
+      assigned_type: roleValue,
+      assigned_customer_id: Number(document.getElementById(`addressAssignedCustomerId-${addressId}`).value || 0) || null,
+      assigned_connection_id: Number(currentAddress?.assigned_connection_id || 0) || null,
+      comment: document.getElementById(`addressComment-${addressId}`).value.trim() || null,
+    };
+
+    const response = await fetch(`/api/v1/internet-connections/${connectionId}/ip-addresses/${addressId}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+      alert('Kunne ikke opdatere IP-adressen');
+      return;
+    }
+    editingAddressId = null;
+    await loadConnection();
+  }
+
+  async function createPricingEntry() {
+    const payload = {
+      effective_from: document.getElementById('pricingEffectiveDateInput').value,
+      purchase_price: Number(document.getElementById('pricingPurchaseInput').value || 0),
+      sales_price: Number(document.getElementById('pricingSalesInput').value || 0),
+      notes: document.getElementById('pricingNotesInput').value.trim() || null,
+    };
+    if (!payload.effective_from) {
+      document.getElementById('pricingFeedback').textContent = 'Fra dato er påkrævet.';
+      return;
+    }
+
+    document.getElementById('pricingFeedback').textContent = 'Gemmer...';
+    const response = await fetch(`/api/v1/internet-connections/${connectionId}/pricing`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+      document.getElementById('pricingFeedback').textContent = 'Kunne ikke gemme prislinjen.';
+      return;
+    }
+    document.getElementById('pricingEffectiveDateInput').value = '';
+    document.getElementById('pricingPurchaseInput').value = '';
+    document.getElementById('pricingSalesInput').value = '';
+    document.getElementById('pricingNotesInput').value = '';
+    document.getElementById('pricingFeedback').textContent = 'Prislinje gemt.';
+    await loadConnection();
+  }
+
+  function resetAddressFilters() {
+    document.getElementById('addressSearchInput').value = '';
+    document.getElementById('addressStatusFilter').value = '';
+    renderAddresses(currentAddresses);
+  }
+
+  document.addEventListener('DOMContentLoaded', () => {
+    document.getElementById('addressSearchInput').addEventListener('input', () => renderAddresses(currentAddresses));
+    document.getElementById('addressStatusFilter').addEventListener('change', () => renderAddresses(currentAddresses));
+    bindLookupInput('fieldCustomerLookup', 'fieldCustomerId', () => customerOptions);
+    bindLookupInput('fieldParentLookup', 'fieldParentId', () => connectionOptions);
+    bindLookupInput('bmcnetWizardCustomerLookup', 'bmcnetWizardCustomerId', () => customerOptions);
+    bindLookupInput('rangeCustomerLookupInput', 'rangeCustomerIdInput', () => customerOptions);
+    bindLookupInput('addressAssignedCustomerInput', 'addressAssignedCustomerIdInput', () => customerOptions);
+    bindLookupInput('addressAssignedConnectionInput', 'addressAssignedConnectionIdInput', () => connectionOptions);
+    document.getElementById('bmcnetWizardSharedHeadSelect').addEventListener('change', async (event) => {
+      await refreshBmcnetWizardHeadState(event.target.value);
+    });
+    document.getElementById('bmcnetWizardInternetProduct').addEventListener('change', () => syncBmcnetWizardPrice('bmcnetWizardInternetProduct', 'bmcnetWizardInternetPrice'));
+    document.getElementById('bmcnetWizardIpProduct').addEventListener('change', async () => {
+      syncBmcnetWizardPrice('bmcnetWizardIpProduct', 'bmcnetWizardIpPrice');
+      await refreshBmcnetWizardAllocationMode();
+    });
+    document.getElementById('bmcnetWizardAddress').addEventListener('change', async () => {
+      await refreshBmcnetWizardAllocationMode();
+    });
+    document.getElementById('fieldSubscriptionLookup').addEventListener('change', () => {
+      document.getElementById('fieldSubscriptionId').value = resolveSubscriptionId(document.getElementById('fieldSubscriptionLookup').value) || '';
+    });
+    const createRangeButton = document.getElementById('createRangeButton');
+    if (createRangeButton) {
+      createRangeButton.addEventListener('click', (event) => {
+        event.preventDefault();
+        createRange();
+      });
+    }
+    loadConnection();
+  });
+</script>
+{% endblock %}
diff --git a/app/modules/internet_connections/templates/index.html b/app/modules/internet_connections/templates/index.html
new file mode 100644
index 0000000..d966dbd
--- /dev/null
+++ b/app/modules/internet_connections/templates/index.html
@@ -0,0 +1,633 @@
+{% extends "shared/frontend/base.html" %}
+
+{% block title %}Internetforbindelser{% endblock %}
+
+{% block extra_css %}
+<style>
+  .internet-hero {
+    background:
+      radial-gradient(circle at top right, rgba(15, 76, 117, 0.18), transparent 34%),
+      linear-gradient(135deg, rgba(15, 76, 117, 0.1), rgba(255, 255, 255, 0.02));
+    border: 1px solid rgba(15, 76, 117, 0.14);
+    border-radius: 24px;
+    padding: 1.5rem;
+    box-shadow: 0 16px 36px rgba(15, 76, 117, 0.08);
+  }
+
+  .internet-panel {
+    background: var(--bg-card);
+    border: 1px solid rgba(15, 76, 117, 0.12);
+    border-radius: 20px;
+    box-shadow: 0 14px 32px rgba(15, 76, 117, 0.06);
+  }
+
+  .internet-kpi {
+    background: linear-gradient(180deg, rgba(15, 76, 117, 0.04), rgba(15, 76, 117, 0.01));
+    border: 1px solid rgba(15, 76, 117, 0.1);
+    border-radius: 16px;
+    padding: 1rem;
+    height: 100%;
+  }
+
+  .internet-kpi-label {
+    color: var(--text-secondary);
+    font-size: 0.78rem;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+  }
+
+  .internet-kpi-value {
+    color: var(--text-primary);
+    font-size: 1.55rem;
+    font-weight: 700;
+  }
+
+  .internet-toolbar {
+    display: grid;
+    grid-template-columns: 1.4fr 1fr 0.8fr 0.9fr auto auto;
+    gap: 0.75rem;
+  }
+
+  .internet-row {
+    cursor: pointer;
+  }
+
+  .internet-row td {
+    vertical-align: middle;
+  }
+
+  .internet-tabs {
+    display: inline-flex;
+    padding: 0.35rem;
+    border-radius: 999px;
+    background: rgba(15, 76, 117, 0.07);
+    gap: 0.35rem;
+  }
+
+  .internet-tab {
+    border: 0;
+    background: transparent;
+    border-radius: 999px;
+    padding: 0.6rem 1rem;
+    font-weight: 700;
+    color: var(--text-secondary);
+  }
+
+  .internet-tab.active {
+    background: #0f4c75;
+    color: white;
+  }
+
+  .internet-tag {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.3rem;
+    border-radius: 999px;
+    padding: 0.18rem 0.5rem;
+    font-size: 0.72rem;
+    font-weight: 700;
+    background: rgba(15, 76, 117, 0.08);
+    color: #0f4c75;
+    margin-right: 0.35rem;
+  }
+
+  .internet-status {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.35rem;
+    padding: 0.35rem 0.7rem;
+    border-radius: 999px;
+    font-size: 0.75rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .internet-status.active {
+    background: rgba(25, 135, 84, 0.12);
+    color: #146c43;
+  }
+
+  .internet-status.inactive {
+    background: rgba(108, 117, 125, 0.14);
+    color: #495057;
+  }
+
+  .internet-status.pending,
+  .internet-status.planned {
+    background: rgba(255, 193, 7, 0.18);
+    color: #997404;
+  }
+
+  .internet-status.terminated,
+  .internet-status.cancelled {
+    background: rgba(220, 53, 69, 0.12);
+    color: #b02a37;
+  }
+
+  .internet-mini {
+    color: var(--text-secondary);
+    font-size: 0.83rem;
+  }
+
+  .internet-quick-form {
+    border: 1px dashed rgba(15, 76, 117, 0.2);
+    border-radius: 18px;
+    background: rgba(15, 76, 117, 0.03);
+    padding: 1rem;
+  }
+
+  @media (max-width: 991px) {
+    .internet-toolbar {
+      grid-template-columns: 1fr;
+    }
+  }
+</style>
+{% endblock %}
+
+{% block content %}
+<div class="container-fluid py-4">
+  <div class="internet-hero mb-4">
+    <div class="d-flex flex-column flex-xl-row justify-content-between align-items-xl-center gap-3">
+      <div>
+        <div class="small text-uppercase fw-semibold text-muted mb-2">Økonomi / Drift / Support</div>
+        <h2 class="h3 mb-1">Internetforbindelser</h2>
+        <div class="text-muted">Samlet overblik over forbindelser, kunder, IP-adresser, kontrakter og dækningsbidrag.</div>
+      </div>
+      <div class="d-flex gap-2 flex-wrap">
+        <button class="btn btn-outline-secondary" type="button" onclick="loadInternetPage()">
+          <i class="bi bi-arrow-repeat me-1"></i>Opdater
+        </button>
+        <button class="btn btn-primary" type="button" data-bs-toggle="collapse" data-bs-target="#createConnectionBlock">
+          <i class="bi bi-plus-lg me-1"></i>Ny forbindelse
+        </button>
+      </div>
+    </div>
+    <div class="internet-tabs mt-3">
+      <button class="internet-tab active" type="button" id="tabAll" onclick="setActiveTab('all')">Alle forbindelser</button>
+      <button class="internet-tab" type="button" id="tabShared" onclick="setActiveTab('shared')">Delte hovedforbindelser</button>
+      <button class="internet-tab" type="button" id="tabBmcnet" onclick="setActiveTab('bmcnet')">BMCnet</button>
+    </div>
+  </div>
+
+  <div class="row g-3 mb-4">
+    <div class="col-6 col-xl-3">
+      <div class="internet-kpi">
+        <div class="internet-kpi-label">Forbindelser</div>
+        <div class="internet-kpi-value" id="metricTotal">0</div>
+      </div>
+    </div>
+    <div class="col-6 col-xl-3">
+      <div class="internet-kpi">
+        <div class="internet-kpi-label">Aktive</div>
+        <div class="internet-kpi-value" id="metricActive">0</div>
+      </div>
+    </div>
+    <div class="col-6 col-xl-3">
+      <div class="internet-kpi">
+        <div class="internet-kpi-label" id="metricSharedLabel">Delte hoveder</div>
+        <div class="internet-kpi-value" id="metricShared">0</div>
+      </div>
+    </div>
+    <div class="col-6 col-xl-3">
+      <div class="internet-kpi">
+        <div class="internet-kpi-label">Dækningsbidrag</div>
+        <div class="internet-kpi-value" id="metricMargin">0 kr.</div>
+      </div>
+    </div>
+  </div>
+
+  <div class="internet-panel p-4 mb-4 collapse" id="createConnectionBlock">
+    <div class="internet-quick-form">
+      <div class="d-flex justify-content-between align-items-center mb-3">
+        <div>
+          <div class="fw-semibold">Opret ny forbindelse</div>
+          <div class="internet-mini">Bruges til fysiske og interne BMC-forbindelser.</div>
+        </div>
+        <div class="small text-muted" id="createConnectionFeedback" role="status"></div>
+      </div>
+      <div class="row g-2">
+        <div class="col-lg-3">
+          <input type="text" class="form-control" id="connectionNameInput" placeholder="Navn" />
+        </div>
+        <div class="col-lg-2">
+          <input type="text" class="form-control" id="connectionProviderInput" placeholder="Leverandør" />
+        </div>
+        <div class="col-lg-2">
+          <input type="number" class="form-control" id="connectionCustomerIdInput" placeholder="Kunde-ID" />
+        </div>
+        <div class="col-lg-2">
+          <input type="text" class="form-control" id="connectionCircuitInput" placeholder="Kredsløb" />
+        </div>
+        <div class="col-lg-3">
+          <input type="text" class="form-control" id="connectionAddressInput" placeholder="Installationsadresse" />
+        </div>
+        <div class="col-lg-2">
+          <select class="form-select" id="connectionAllocationInput">
+            <option value="dedicated">Dedikeret</option>
+            <option value="shared">Delt</option>
+          </select>
+        </div>
+        <div class="col-lg-2">
+          <select class="form-select" id="connectionValueTypeInput" onchange="toggleCreateValueFields()">
+            <option value="other">Anden værdi</option>
+            <option value="subscription">Abonnement</option>
+            <option value="bmc_networks">BMC Networks</option>
+            <option value="delefiber">Delefiber</option>
+          </select>
+        </div>
+        <div class="col-lg-4" id="createValueLabelWrap">
+          <input type="text" class="form-control" id="connectionValueLabelInput" placeholder="Værdi / klassifikation" value="Mangler klassifikation" />
+        </div>
+        <div class="col-lg-4 d-none" id="createSubscriptionWrap">
+          <input type="text" class="form-control" id="connectionSubscriptionInput" list="subscriptionLookupList" placeholder="Abonnement">
+          <input type="hidden" id="connectionSubscriptionIdInput" />
+        </div>
+        <div class="col-lg-2">
+          <input type="text" class="form-control" id="connectionTechnologyInput" placeholder="Teknologi" />
+        </div>
+        <div class="col-lg-2">
+          <input type="number" class="form-control" id="connectionDownloadInput" placeholder="Download" />
+        </div>
+        <div class="col-lg-2">
+          <input type="number" class="form-control" id="connectionUploadInput" placeholder="Upload" />
+        </div>
+        <div class="col-lg-2">
+          <input type="number" class="form-control" id="connectionPurchaseInput" placeholder="Kost" />
+        </div>
+        <div class="col-lg-2">
+          <input type="number" class="form-control" id="connectionSalesInput" placeholder="Salg" />
+        </div>
+        <div class="col-lg-2">
+          <select class="form-select" id="connectionStatusInput">
+            <option value="active">Aktiv</option>
+            <option value="planned">Planlagt</option>
+            <option value="inactive">Inaktiv</option>
+          </select>
+        </div>
+        <div class="col-12">
+          <textarea class="form-control" id="connectionNotesInput" rows="2" placeholder="Noter, SLA, overvågning, intern struktur..."></textarea>
+        </div>
+      </div>
+      <div class="mt-3">
+        <button class="btn btn-primary" type="button" onclick="submitConnectionForm()">Gem forbindelse</button>
+      </div>
+    </div>
+  </div>
+
+  <div class="internet-panel p-4 mb-4">
+    <div class="internet-toolbar mb-3">
+      <input type="search" class="form-control" id="searchInput" placeholder="Søg navn, kunde, leverandør, kredsløb eller adresse" />
+      <input type="text" class="form-control" id="providerFilter" placeholder="Filtrer leverandør" />
+      <select class="form-select" id="statusFilter">
+        <option value="">Alle statusser</option>
+        <option value="active">Aktive</option>
+        <option value="planned">Planlagte</option>
+        <option value="inactive">Inaktive</option>
+        <option value="terminated">Opsagte</option>
+      </select>
+      <select class="form-select" id="valueTypeFilter">
+        <option value="">Alle værdier</option>
+        <option value="subscription">Abonnement</option>
+        <option value="bmc_networks">BMC Networks</option>
+        <option value="delefiber">Delefiber</option>
+        <option value="other">Anden</option>
+      </select>
+      <button class="btn btn-outline-secondary" type="button" onclick="loadInternetPage()">Anvend</button>
+      <button class="btn btn-light border" type="button" onclick="resetFilters()">Nulstil</button>
+    </div>
+
+    <div class="row g-3 mb-3">
+      <div class="col-xl-6">
+        <div class="internet-mini" id="pageSummaryText">Indlæser forbindelser...</div>
+      </div>
+      <div class="col-xl-6 text-xl-end">
+        <div class="internet-mini">Klik på en række for at åbne forbindelsesdetaljer.</div>
+      </div>
+    </div>
+
+    <div class="table-responsive">
+      <table class="table align-middle mb-0">
+        <thead class="table-light">
+          <tr>
+            <th>Forbindelse</th>
+            <th>Kunde</th>
+            <th>Leverandør / kredsløb</th>
+            <th>Hastighed / IP</th>
+            <th>Økonomi</th>
+            <th>Status</th>
+            <th></th>
+          </tr>
+        </thead>
+        <tbody id="connectionsTableBody">
+          <tr>
+            <td colspan="7" class="text-muted py-4">Indlæser...</td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+  </div>
+</div>
+
+<script>
+  let allConnections = [];
+  let activeTab = 'all';
+  let subscriptionOptions = [];
+
+  function formatDKK(value) {
+    return Number(value || 0).toLocaleString('da-DK', { style: 'currency', currency: 'DKK', minimumFractionDigits: 0 });
+  }
+
+  function formatSpeed(item) {
+    const down = Number(item.download_mbps || 0);
+    const up = Number(item.upload_mbps || 0);
+    const speed = Number(item.speed_mbps || 0);
+    if (down || up) return `${down || 0}/${up || 0} Mbps`;
+    if (speed) return `${speed} Mbps`;
+    return '-';
+  }
+
+  function statusBadge(status) {
+    const value = String(status || 'inactive').toLowerCase();
+    const labelMap = {
+      active: 'Aktiv',
+      planned: 'Planlagt',
+      pending: 'Afventer',
+      inactive: 'Inaktiv',
+      terminated: 'Opsagt',
+      cancelled: 'Annulleret',
+    };
+    return `<span class="internet-status ${value}">${labelMap[value] || value}</span>`;
+  }
+
+  function allocationBadge(item) {
+    const label = item.allocation_model_label || (item.allocation_model === 'shared' ? 'Delt' : 'Dedikeret');
+    return `<span class="internet-tag">${label}</span>`;
+  }
+
+  function valueBadge(item) {
+    const label = item.value_type_label || 'Anden';
+    return `<span class="internet-tag">${label}</span>`;
+  }
+
+  function currentTabDescription() {
+    if (activeTab === 'shared') return ' i delte hovedforbindelser';
+    if (activeTab === 'bmcnet') return ' i BMCnet';
+    return '';
+  }
+
+  async function safeJson(response, fallback) {
+    if (!response.ok) return fallback;
+    try {
+      return await response.json();
+    } catch {
+      return fallback;
+    }
+  }
+
+  async function extractErrorMessage(response, fallback) {
+    try {
+      const payload = await response.clone().json();
+      if (typeof payload?.detail === 'string' && payload.detail.trim()) return payload.detail.trim();
+      if (Array.isArray(payload?.detail)) {
+        const validation = payload.detail
+          .map((item) => item?.msg || item?.message || '')
+          .filter(Boolean)
+          .join(', ');
+        if (validation) return validation;
+      }
+    } catch (_) {}
+
+    try {
+      const text = (await response.text()).trim();
+      if (text) return text;
+    } catch (_) {}
+    return fallback;
+  }
+
+  async function loadInternetPage() {
+    const search = document.getElementById('searchInput').value.trim();
+    const provider = document.getElementById('providerFilter').value.trim();
+    const status = document.getElementById('statusFilter').value;
+    const valueType = document.getElementById('valueTypeFilter').value;
+    const params = new URLSearchParams();
+    if (search) params.set('q', search);
+    if (provider) params.set('provider', provider);
+    if (status) params.set('status', status);
+    if (valueType) params.set('value_type', valueType);
+    if (activeTab === 'shared') params.set('shared_only', 'true');
+    if (activeTab === 'bmcnet') params.set('bmcnet_only', 'true');
+
+    try {
+      const connectionsResponse = await fetch(`/api/v1/internet-connections?${params.toString()}`);
+
+      const connections = await safeJson(connectionsResponse, []);
+      allConnections = Array.isArray(connections) ? connections : [];
+      const total = allConnections.length;
+      const active = allConnections.filter((item) => item.status === 'active').length;
+      const sharedHeads = allConnections.filter((item) => item.is_shared_head).length;
+      const bmcnetConnections = allConnections.filter((item) => item.is_bmcnet_connection).length;
+      const margin = allConnections.reduce((sum, item) => sum + Number(item.margin_amount || 0), 0);
+
+      document.getElementById('metricTotal').textContent = String(total);
+      document.getElementById('metricActive').textContent = String(active);
+      document.getElementById('metricSharedLabel').textContent = activeTab === 'bmcnet' ? 'BMCnet' : 'Delte hoveder';
+      document.getElementById('metricShared').textContent = String(activeTab === 'bmcnet' ? bmcnetConnections : sharedHeads);
+      document.getElementById('metricMargin').textContent = formatDKK(margin);
+
+      renderConnections(allConnections);
+    } catch (error) {
+      document.getElementById('connectionsTableBody').innerHTML = '<tr><td colspan="7" class="text-danger py-4">Kunne ikke indlæse internetforbindelser.</td></tr>';
+      document.getElementById('pageSummaryText').textContent = 'Indlæsning fejlede.';
+    }
+  }
+
+  function renderConnections(connections) {
+    const body = document.getElementById('connectionsTableBody');
+    document.getElementById('pageSummaryText').textContent = `${connections.length} forbindelser vist${currentTabDescription()}`;
+
+    if (!connections.length) {
+      body.innerHTML = '<tr><td colspan="7" class="text-muted py-4">Ingen forbindelser matcher filtrene.</td></tr>';
+      return;
+    }
+
+    body.innerHTML = connections.map((item) => `
+      <tr class="internet-row" onclick="window.location.href='/economy/internet-connections/${item.id}'">
+        <td>
+          <div class="fw-semibold">${item.name || '-'}</div>
+          <div class="mb-1">${allocationBadge(item)}${valueBadge(item)}</div>
+          <div class="internet-mini">${item.address || '-'}</div>
+          ${item.parent_name ? `<div class="internet-mini"><i class="bi bi-diagram-2 me-1"></i>Under ${item.parent_name}</div>` : ''}
+          ${item.is_shared_head ? `<div class="internet-mini"><i class="bi bi-diagram-3 me-1"></i>${Number(item.bmcnet_child_count || 0)} BMCnet-kunder · ${formatDKK(item.bmcnet_child_sales_price || 0)} salg</div>` : ''}
+        </td>
+        <td>
+          <div>${item.customer_name || '-'}</div>
+          <div class="internet-mini">Kunde-ID: ${item.customer_id || '-'}</div>
+        </td>
+        <td>
+          <div>${item.provider || '-'}</div>
+          <div class="internet-mini">${item.circuit_number || 'Intet kredsløb'}</div>
+          ${item.subscription_number ? `<div class="internet-mini">Abonnement ${item.subscription_number} · ${item.subscription_product_name || '-'}</div>` : (item.value_label ? `<div class="internet-mini">${item.value_label}</div>` : '')}
+        </td>
+        <td>
+          <div>${formatSpeed(item)}</div>
+          <div class="internet-mini">Ranges ${Number(item.ip_range_count || 0)} · IP i brug: ${Number(item.in_use_ip_addresses || 0)} / ${Number(item.total_ip_addresses || 0)}</div>
+          ${item.is_shared_head ? `<div class="internet-mini">BMCnet-IP i brug: ${Number(item.bmcnet_child_ip_count || 0)}</div>` : ''}
+        </td>
+        <td>
+          <div>${formatDKK(item.sales_price || 0)}</div>
+          <div class="internet-mini">Kost ${formatDKK(item.monthly_cost || 0)} · DB ${formatDKK(item.margin_amount || 0)}</div>
+        </td>
+        <td>${statusBadge(item.status)}</td>
+        <td class="text-end">
+          <a href="/economy/internet-connections/${item.id}" class="btn btn-sm btn-outline-primary" onclick="event.stopPropagation()">
+            Åbn
+          </a>
+        </td>
+      </tr>
+    `).join('');
+  }
+
+  async function submitConnectionForm() {
+    const feedback = document.getElementById('createConnectionFeedback');
+    const saveButton = document.querySelector('#createConnectionBlock button.btn.btn-primary');
+    const payload = {
+      name: document.getElementById('connectionNameInput').value.trim(),
+      provider: document.getElementById('connectionProviderInput').value.trim() || null,
+      customer_id: Number(document.getElementById('connectionCustomerIdInput').value || 0) || null,
+      circuit_number: document.getElementById('connectionCircuitInput').value.trim() || null,
+      address: document.getElementById('connectionAddressInput').value.trim() || null,
+      technology: document.getElementById('connectionTechnologyInput').value.trim() || null,
+      download_mbps: Number(document.getElementById('connectionDownloadInput').value || 0) || null,
+      upload_mbps: Number(document.getElementById('connectionUploadInput').value || 0) || null,
+      monthly_cost: Number(document.getElementById('connectionPurchaseInput').value || 0),
+      sales_price: Number(document.getElementById('connectionSalesInput').value || 0),
+      status: document.getElementById('connectionStatusInput').value || 'active',
+      notes: document.getElementById('connectionNotesInput').value.trim() || null,
+      connection_type: 'fiber',
+      allocation_model: document.getElementById('connectionAllocationInput').value || 'dedicated',
+      value_type: document.getElementById('connectionValueTypeInput').value || 'other',
+      value_label: document.getElementById('connectionValueLabelInput').value.trim() || null,
+      subscription_id: Number(document.getElementById('connectionSubscriptionIdInput').value || 0) || null,
+    };
+
+    if (!payload.name) {
+      feedback.textContent = 'Navn er påkrævet.';
+      return;
+    }
+    if (!payload.address) {
+      feedback.textContent = 'Adresse er påkrævet.';
+      return;
+    }
+    if (payload.value_type === 'subscription' && !payload.subscription_id) {
+      feedback.textContent = 'Vælg et gyldigt abonnement.';
+      return;
+    }
+
+    feedback.textContent = 'Gemmer...';
+    if (saveButton) saveButton.disabled = true;
+    try {
+      const response = await fetch('/api/v1/internet-connections', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        feedback.textContent = await extractErrorMessage(response, 'Kunne ikke gemme forbindelsen.');
+        return;
+      }
+
+      feedback.textContent = 'Forbindelse oprettet.';
+      [
+        'connectionNameInput',
+        'connectionProviderInput',
+        'connectionCustomerIdInput',
+        'connectionCircuitInput',
+        'connectionAddressInput',
+        'connectionTechnologyInput',
+        'connectionDownloadInput',
+        'connectionUploadInput',
+        'connectionPurchaseInput',
+        'connectionSalesInput',
+        'connectionNotesInput',
+      ].forEach((id) => {
+        const field = document.getElementById(id);
+        if (field) field.value = '';
+      });
+      document.getElementById('connectionStatusInput').value = 'active';
+      document.getElementById('connectionAllocationInput').value = 'dedicated';
+      document.getElementById('connectionValueTypeInput').value = 'other';
+      document.getElementById('connectionValueLabelInput').value = 'Mangler klassifikation';
+      document.getElementById('connectionSubscriptionInput').value = '';
+      document.getElementById('connectionSubscriptionIdInput').value = '';
+      toggleCreateValueFields();
+      await loadInternetPage();
+    } catch (error) {
+      feedback.textContent = error?.message || 'Netværksfejl under gem.';
+    } finally {
+      if (saveButton) saveButton.disabled = false;
+    }
+  }
+
+  function resetFilters() {
+    document.getElementById('searchInput').value = '';
+    document.getElementById('providerFilter').value = '';
+    document.getElementById('statusFilter').value = '';
+    document.getElementById('valueTypeFilter').value = '';
+    loadInternetPage();
+  }
+
+  function setActiveTab(tab) {
+    activeTab = tab;
+    document.getElementById('tabAll').classList.toggle('active', tab === 'all');
+    document.getElementById('tabShared').classList.toggle('active', tab === 'shared');
+    document.getElementById('tabBmcnet').classList.toggle('active', tab === 'bmcnet');
+    loadInternetPage();
+  }
+
+  function toggleCreateValueFields() {
+    const valueType = document.getElementById('connectionValueTypeInput').value;
+    document.getElementById('createValueLabelWrap').classList.toggle('d-none', valueType !== 'other');
+    document.getElementById('createSubscriptionWrap').classList.toggle('d-none', valueType !== 'subscription');
+  }
+
+  function buildSubscriptionLabel(item) {
+    return `${item.id} · ${item.subscription_number || '-'} · ${item.product_name || '-'} · ${item.customer_name || '-'}`;
+  }
+
+  function resolveSubscriptionId(value) {
+    const raw = String(value || '').trim();
+    if (!raw) return null;
+    const idMatch = raw.match(/^(\d+)\b/);
+    if (idMatch) return Number(idMatch[1]);
+    const matched = subscriptionOptions.find((item) => buildSubscriptionLabel(item).toLowerCase() === raw.toLowerCase());
+    return matched ? Number(matched.id) : null;
+  }
+
+  async function loadSubscriptionOptions() {
+    try {
+      const response = await fetch('/api/v1/internet-connections/subscription-options');
+      subscriptionOptions = response.ok ? await response.json() : [];
+    } catch (error) {
+      subscriptionOptions = [];
+    }
+    document.getElementById('subscriptionLookupList').innerHTML = subscriptionOptions
+      .map((item) => `<option value="${buildSubscriptionLabel(item)}"></option>`)
+      .join('');
+  }
+
+  document.addEventListener('DOMContentLoaded', async () => {
+    document.getElementById('searchInput').addEventListener('keydown', (event) => {
+      if (event.key === 'Enter') loadInternetPage();
+    });
+    document.getElementById('connectionSubscriptionInput').addEventListener('change', () => {
+      document.getElementById('connectionSubscriptionIdInput').value = resolveSubscriptionId(document.getElementById('connectionSubscriptionInput').value) || '';
+    });
+    toggleCreateValueFields();
+    await loadSubscriptionOptions();
+    await loadInternetPage();
+  });
+</script>
+<datalist id="subscriptionLookupList"></datalist>
+{% endblock %}
diff --git a/app/modules/internet_connections/templates/migration_wizard_v2.html b/app/modules/internet_connections/templates/migration_wizard_v2.html
new file mode 100644
index 0000000..65d6beb
--- /dev/null
+++ b/app/modules/internet_connections/templates/migration_wizard_v2.html
@@ -0,0 +1,557 @@
+{% extends "shared/frontend/base.html" %}
+
+{% block title %}Internet Wizard v2{% endblock %}
+
+{% block extra_css %}
+<style>
+  .wiz-hero {
+    background:
+      radial-gradient(circle at top right, rgba(15, 76, 117, 0.16), transparent 36%),
+      linear-gradient(135deg, rgba(15, 76, 117, 0.1), rgba(255, 255, 255, 0.02));
+    border: 1px solid rgba(15, 76, 117, 0.12);
+    border-radius: 24px;
+    padding: 1.5rem;
+    box-shadow: 0 14px 34px rgba(15, 76, 117, 0.06);
+  }
+
+  .wiz-panel {
+    background: var(--bg-card);
+    border: 1px solid rgba(15, 76, 117, 0.12);
+    border-radius: 20px;
+    box-shadow: 0 14px 30px rgba(15, 76, 117, 0.05);
+  }
+
+  .wiz-kpi {
+    border: 1px solid rgba(15, 76, 117, 0.1);
+    border-radius: 16px;
+    padding: 1rem;
+    background: linear-gradient(180deg, rgba(15, 76, 117, 0.04), rgba(15, 76, 117, 0.01));
+  }
+
+  .wiz-kpi-label {
+    font-size: 0.75rem;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: var(--text-secondary);
+    font-weight: 700;
+  }
+
+  .wiz-kpi-value {
+    font-size: 1.4rem;
+    font-weight: 700;
+    color: var(--text-primary);
+  }
+
+  .wiz-grid {
+    display: grid;
+    grid-template-columns: 1.2fr 0.8fr;
+    gap: 1rem;
+  }
+
+  .wiz-card {
+    border: 1px solid rgba(15, 76, 117, 0.1);
+    border-radius: 16px;
+    padding: 1rem;
+    background: rgba(15, 76, 117, 0.03);
+  }
+
+  .wiz-card h3 {
+    font-size: 1rem;
+    margin-bottom: 0.35rem;
+  }
+
+  .wiz-meta {
+    color: var(--text-secondary);
+    font-size: 0.85rem;
+  }
+
+  .wiz-snippet {
+    border-left: 3px solid rgba(15, 76, 117, 0.25);
+    padding-left: 0.8rem;
+    margin-top: 0.75rem;
+    color: var(--text-primary);
+  }
+
+  .wiz-upload-box {
+    border: 1px dashed rgba(15, 76, 117, 0.24);
+    border-radius: 16px;
+    padding: 1rem;
+    background: rgba(15, 76, 117, 0.025);
+  }
+
+  .wiz-empty {
+    color: var(--text-secondary);
+    font-style: italic;
+  }
+
+  .wiz-pill {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.35rem;
+    border-radius: 999px;
+    padding: 0.35rem 0.7rem;
+    background: rgba(15, 76, 117, 0.08);
+    color: #0f4c75;
+    font-size: 0.78rem;
+    font-weight: 700;
+  }
+
+  .wiz-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.85rem;
+  }
+
+  .wiz-summary {
+    min-height: 110px;
+    white-space: pre-wrap;
+  }
+
+  @media (max-width: 991px) {
+    .wiz-grid {
+      grid-template-columns: 1fr;
+    }
+  }
+</style>
+{% endblock %}
+
+{% block content %}
+<div class="container-fluid py-4">
+  <div class="wiz-hero mb-4">
+    <div class="d-flex flex-column flex-xl-row justify-content-between align-items-xl-center gap-3">
+      <div>
+        <div class="small text-uppercase fw-semibold text-muted mb-2">Data migration / Internet</div>
+        <h2 class="h3 mb-1">Internet Wizard v2</h2>
+        <div class="text-muted">Midlertidig research-wizard til gamle kundetekster, internetnoter og leverandørfakturaer fra de sidste 18 måneder.</div>
+      </div>
+      <div class="wiz-pill">
+        <i class="bi bi-magic"></i>
+        Temp version
+      </div>
+    </div>
+  </div>
+
+  <div class="wiz-panel p-4 mb-4">
+    <div class="row g-3 align-items-end">
+      <div class="col-lg-5">
+        <label class="form-label fw-semibold">Kunde</label>
+        <input type="text" class="form-control" id="customerSearchInput" list="customerOptions" placeholder="Søg kunde og vælg fra listen">
+        <datalist id="customerOptions"></datalist>
+        <input type="hidden" id="selectedCustomerId">
+        <div class="wiz-meta mt-2" id="selectedCustomerMeta">Ingen kunde valgt endnu.</div>
+      </div>
+      <div class="col-lg-5">
+        <label class="form-label fw-semibold">Søgning / fokus</label>
+        <input type="text" class="form-control" id="queryInput" placeholder="fx fiber, MPLS, Lejrvej, public IP, gammel aftale">
+      </div>
+      <div class="col-lg-2 d-grid">
+        <button class="btn btn-primary" type="button" onclick="loadWizardContext()">
+          <i class="bi bi-search me-1"></i>Vis info
+        </button>
+      </div>
+    </div>
+  </div>
+
+  <div class="row g-3 mb-4">
+    <div class="col-6 col-xl-3">
+      <div class="wiz-kpi">
+        <div class="wiz-kpi-label">Kundefiler</div>
+        <div class="wiz-kpi-value" id="metricDocuments">0</div>
+      </div>
+    </div>
+    <div class="col-6 col-xl-3">
+        <div class="wiz-kpi">
+        <div class="wiz-kpi-label">Blokfund</div>
+        <div class="wiz-kpi-value" id="metricSnippets">0</div>
+      </div>
+    </div>
+    <div class="col-6 col-xl-3">
+      <div class="wiz-kpi">
+        <div class="wiz-kpi-label">Internetfakturaer</div>
+        <div class="wiz-kpi-value" id="metricInvoices">0</div>
+      </div>
+    </div>
+    <div class="col-6 col-xl-3">
+      <div class="wiz-kpi">
+        <div class="wiz-kpi-label">Status</div>
+        <div class="wiz-kpi-value fs-6" id="wizardStatusText">Venter</div>
+      </div>
+    </div>
+  </div>
+
+  <div class="wiz-grid mb-4">
+    <div class="wiz-panel p-4">
+      <div class="d-flex justify-content-between align-items-center mb-3">
+        <div>
+          <h3 class="mb-1">AI-overblik</h3>
+          <div class="wiz-meta">Kort opsummering fra kundefiler og relevante internetfakturaer.</div>
+        </div>
+      </div>
+      <div class="wiz-card wiz-summary" id="aiSummaryBox">Vælg en kunde for at hente kontekst.</div>
+    </div>
+
+    <div class="wiz-panel p-4">
+      <div class="d-flex justify-content-between align-items-center mb-3">
+        <div>
+          <h3 class="mb-1">Upload tekstfiler</h3>
+          <div class="wiz-meta">Upload delte batch-filer med flere kunder. Systemet splitter dem i søgbare blokke med fx IP, CIDR, stiknr og referencer.</div>
+        </div>
+      </div>
+      <div class="wiz-upload-box">
+        <div class="mb-2">
+          <input type="file" class="form-control" id="customerFileInput" accept=".txt,.csv,.log,.md">
+        </div>
+        <div class="mb-2">
+          <textarea class="form-control" id="customerFileNotes" rows="3" placeholder="Noter om filen eller kontekst"></textarea>
+        </div>
+        <div class="d-grid">
+          <button class="btn btn-outline-primary" type="button" onclick="uploadCustomerFile()">
+            <i class="bi bi-upload me-1"></i>Upload fil
+          </button>
+        </div>
+        <div class="wiz-meta mt-2" id="uploadStatus">Ingen upload kørt endnu.</div>
+      </div>
+    </div>
+  </div>
+
+  <div class="row g-4">
+    <div class="col-xl-6">
+      <div class="wiz-panel p-4 h-100">
+        <div class="d-flex justify-content-between align-items-center mb-3">
+          <div>
+            <h3 class="mb-1">Kundetekster</h3>
+            <div class="wiz-meta">Uploadede filer og de bedste fund fra dem.</div>
+          </div>
+        </div>
+        <div class="wiz-list" id="documentList">
+          <div class="wiz-empty">Ingen dokumenter endnu.</div>
+        </div>
+      </div>
+    </div>
+    <div class="col-xl-6">
+      <div class="wiz-panel p-4 mb-4">
+        <div class="d-flex justify-content-between align-items-center mb-3">
+          <div>
+            <h3 class="mb-1">Præcise blokfund</h3>
+            <div class="wiz-meta">Her finder du den konkrete tekstblok med fx IP, stiknr eller reference.</div>
+          </div>
+        </div>
+        <div class="wiz-list" id="segmentList">
+          <div class="wiz-empty">Ingen blokfund endnu.</div>
+        </div>
+      </div>
+    </div>
+    <div class="col-xl-12">
+      <div class="wiz-panel p-4 h-100">
+        <div class="d-flex justify-content-between align-items-center mb-3">
+          <div>
+            <h3 class="mb-1">Relaterede fakturaer</h3>
+            <div class="wiz-meta">De sidste 18 måneder med internet/bredbånd-relateret tekst.</div>
+          </div>
+        </div>
+        <div class="wiz-list" id="invoiceList">
+          <div class="wiz-empty">Ingen fakturafund endnu.</div>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>
+{% endblock %}
+
+{% block extra_js %}
+<script>
+  let customerSearchTimer = null;
+  let customerOptions = [];
+  let localUploadedDocuments = [];
+
+  function escapeHtml(value) {
+    return String(value ?? '')
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#39;');
+  }
+
+  function formatDate(value) {
+    if (!value) return '-';
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) return value;
+    return parsed.toLocaleDateString('da-DK');
+  }
+
+  function formatBytes(value) {
+    const size = Number(value || 0);
+    if (!size) return '0 B';
+    if (size < 1024) return `${size} B`;
+    if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)} KB`;
+    return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+  }
+
+  function formatMoney(value, currency = 'DKK') {
+    return new Intl.NumberFormat('da-DK', {
+      style: 'currency',
+      currency: currency || 'DKK',
+      minimumFractionDigits: 2,
+    }).format(Number(value || 0));
+  }
+
+  function setWizardStatus(text) {
+    document.getElementById('wizardStatusText').textContent = text;
+  }
+
+  function renderLocalDocumentsOnly(documents = []) {
+    document.getElementById('metricDocuments').textContent = String(documents.length);
+    document.getElementById('metricSnippets').textContent = '0';
+    document.getElementById('metricInvoices').textContent = '0';
+    document.getElementById('aiSummaryBox').textContent = 'Viser uploadede filer. Vælg kunde eller genindlæs siden efter backend-genstart for fuld kontekst.';
+
+    const documentList = document.getElementById('documentList');
+    if (!documents.length) {
+      documentList.innerHTML = '<div class="wiz-empty">Ingen dokumenter i det delte arkiv endnu.</div>';
+    } else {
+      documentList.innerHTML = documents.map(item => `
+        <div class="wiz-card">
+          <div class="d-flex justify-content-between align-items-start gap-3">
+            <div>
+              <h3>${escapeHtml(item.original_filename || item.filename || 'Uploadet fil')}</h3>
+              <div class="wiz-meta">${item.created_at ? formatDate(item.created_at) + ' · ' : ''}${item.file_size ? formatBytes(item.file_size) + ' · ' : ''}${escapeHtml(item.mime_type || '-')}</div>
+            </div>
+            <span class="wiz-pill">${item.segment_count || 0} blokke</span>
+          </div>
+          ${(item.notes ? `<div class="wiz-meta mt-2">${escapeHtml(item.notes)}</div>` : '')}
+        </div>
+      `).join('');
+    }
+
+    document.getElementById('segmentList').innerHTML = '<div class="wiz-empty">Vælg kunde eller søg på IP/stiknr/reference for konkrete blokfund.</div>';
+    document.getElementById('invoiceList').innerHTML = '<div class="wiz-empty">Vælg kunde for at se relaterede internetfakturaer.</div>';
+  }
+
+  function renderCustomerOptions(items) {
+    customerOptions = items || [];
+    const list = document.getElementById('customerOptions');
+    list.innerHTML = customerOptions.map(item => (
+      `<option value="${escapeHtml(item.name)}" data-id="${item.id}"></option>`
+    )).join('');
+  }
+
+  async function searchCustomers(query) {
+    const response = await fetch(`/api/v1/customers?search=${encodeURIComponent(query)}&limit=15&is_active=true`);
+    if (!response.ok) return [];
+    const payload = await response.json();
+    return Array.isArray(payload) ? payload : (payload.customers || payload.items || []);
+  }
+
+  async function onCustomerInputChanged() {
+    const input = document.getElementById('customerSearchInput');
+    const query = input.value.trim();
+    document.getElementById('selectedCustomerId').value = '';
+    document.getElementById('selectedCustomerMeta').textContent = 'Vælg kunde fra listen.';
+
+    const exact = customerOptions.find(item => item.name === query);
+    if (exact) {
+      document.getElementById('selectedCustomerId').value = exact.id;
+      document.getElementById('selectedCustomerMeta').textContent = `Kunde-ID ${exact.id} · ${exact.name}`;
+      return;
+    }
+
+    if (query.length < 2) return;
+    const items = await searchCustomers(query);
+    renderCustomerOptions(items);
+  }
+
+  async function loadWizardContext() {
+    const customerId = document.getElementById('selectedCustomerId').value;
+    const query = document.getElementById('queryInput').value.trim();
+    setWizardStatus('Henter');
+    if (!customerId && !query) {
+      try {
+        const docRes = await fetch('/api/v1/internet-connections/customer-documents');
+        if (docRes.ok) {
+          const docPayload = await docRes.json();
+          const docs = docPayload.documents || [];
+          renderLocalDocumentsOnly(docs);
+          setWizardStatus('Klar');
+          return;
+        }
+      } catch (error) {
+        console.warn('Could not load shared document list', error);
+      }
+      if (localUploadedDocuments.length) {
+        renderLocalDocumentsOnly(localUploadedDocuments);
+        setWizardStatus('Klar');
+        return;
+      }
+    }
+    const params = new URLSearchParams();
+    if (customerId) {
+      params.set('customer_id', customerId);
+    }
+    if (query) {
+      params.set('query', query);
+    }
+    const response = await fetch(`/api/v1/internet-connections/migration-wizard-v2/context?${params.toString()}`);
+    if (!response.ok) {
+      let payload = {};
+      try {
+        payload = await response.json();
+      } catch (error) {
+        payload = {};
+      }
+      const detail = JSON.stringify(payload.detail || '');
+      if (!customerId && detail.includes('customer_id')) {
+        if (localUploadedDocuments.length) {
+          renderLocalDocumentsOnly(localUploadedDocuments);
+          setWizardStatus('Klar');
+          return;
+        }
+        setWizardStatus('Venter');
+        return;
+      }
+      setWizardStatus('Fejl');
+      const errorText = payload.detail ? JSON.stringify(payload.detail) : await response.text();
+      alert(`Kunne ikke hente kontekst: ${errorText}`);
+      return;
+    }
+    const payload = await response.json();
+    renderWizardContext(payload);
+    setWizardStatus('Klar');
+  }
+
+  function renderWizardContext(payload) {
+    const documents = payload.documents || [];
+    const invoiceHits = payload.invoice_hits || [];
+    const segmentHits = payload.segment_hits || [];
+    const customer = payload.customer || null;
+
+    document.getElementById('metricDocuments').textContent = String(documents.length);
+    document.getElementById('metricSnippets').textContent = String(segmentHits.length);
+    document.getElementById('metricInvoices').textContent = String(invoiceHits.length);
+    document.getElementById('aiSummaryBox').textContent = payload.ai_summary || (customer ? 'Ingen AI-opsummering endnu.' : 'Viser delt arkiv. Vælg kunde eller søg på IP/stiknr/reference for mere præcise fund.');
+    document.getElementById('selectedCustomerMeta').textContent = customer
+      ? `Kunde-ID ${customer.id} · ${customer.name}`
+      : 'Delt arkiv uden valgt kunde.';
+
+    const documentList = document.getElementById('documentList');
+    if (!documents.length) {
+      documentList.innerHTML = `<div class="wiz-empty">${customer ? 'Ingen kundefiler fundet for denne kunde.' : 'Ingen dokumenter i det delte arkiv endnu.'}</div>`;
+    } else {
+      documentList.innerHTML = documents.map(item => `
+        <div class="wiz-card">
+          <div class="d-flex justify-content-between align-items-start gap-3">
+            <div>
+              <h3>${escapeHtml(item.original_filename)}</h3>
+              <div class="wiz-meta">${formatDate(item.created_at)} · ${formatBytes(item.file_size)} · ${escapeHtml(item.mime_type || '-')}</div>
+            </div>
+            <span class="wiz-pill">${item.snippet_count || 0} fund</span>
+          </div>
+          ${(item.notes ? `<div class="wiz-meta mt-2">${escapeHtml(item.notes)}</div>` : '')}
+          ${(item.snippets || []).map(snippet => `<div class="wiz-snippet">${escapeHtml(snippet)}</div>`).join('')}
+        </div>
+      `).join('');
+    }
+
+    const segmentList = document.getElementById('segmentList');
+    if (!segmentHits.length) {
+      segmentList.innerHTML = `<div class="wiz-empty">${customer ? 'Ingen blokke matcher kunden og søgningen endnu.' : 'Ingen blokfund i arkivet endnu.'}</div>`;
+    } else {
+      segmentList.innerHTML = segmentHits.map(item => `
+        <div class="wiz-card">
+          <div class="d-flex justify-content-between align-items-start gap-3">
+            <div>
+              <h3>${escapeHtml(item.title || 'Blok')}</h3>
+              <div class="wiz-meta">Dokument #${item.document_id} · score ${item.score}</div>
+            </div>
+            <span class="wiz-pill">blok ${Number(item.block_index || 0) + 1}</span>
+          </div>
+          <div class="wiz-snippet">${escapeHtml(item.snippet || '-')}</div>
+          <div class="wiz-meta mt-2">
+            ${(item.ip_addresses || []).length ? `IP: ${escapeHtml(item.ip_addresses.join(', '))}` : ''}
+            ${(item.cidr_blocks || []).length ? `${(item.ip_addresses || []).length ? ' · ' : ''}CIDR: ${escapeHtml(item.cidr_blocks.join(', '))}` : ''}
+            ${(item.references || []).length ? `${((item.ip_addresses || []).length || (item.cidr_blocks || []).length) ? ' · ' : ''}Ref: ${escapeHtml(item.references.join(', '))}` : ''}
+            ${(item.socket_numbers || []).length ? `${((item.ip_addresses || []).length || (item.cidr_blocks || []).length || (item.references || []).length) ? ' · ' : ''}Stik: ${escapeHtml(item.socket_numbers.join(', '))}` : ''}
+          </div>
+        </div>
+      `).join('');
+    }
+
+    const invoiceList = document.getElementById('invoiceList');
+    if (!invoiceHits.length) {
+      invoiceList.innerHTML = `<div class="wiz-empty">${customer ? 'Ingen internetrelaterede fakturafund de sidste 18 måneder.' : 'Vælg kunde for at se relaterede internetfakturaer.'}</div>`;
+    } else {
+      invoiceList.innerHTML = invoiceHits.map(item => `
+        <div class="wiz-card">
+          <div class="d-flex justify-content-between align-items-start gap-3">
+            <div>
+              <h3>${escapeHtml(item.vendor_name)} · ${escapeHtml(item.invoice_number || '-')}</h3>
+              <div class="wiz-meta">${formatDate(item.invoice_date)} · ${formatMoney(item.total_amount, item.currency)}${item.directly_linked ? ' · koblet til kunde' : ''}</div>
+            </div>
+            <span class="wiz-pill">score ${item.score}</span>
+          </div>
+          ${(item.source_filename ? `<div class="wiz-meta mt-2">Fil: ${escapeHtml(item.source_filename)}</div>` : '')}
+          ${(item.snippets || []).map(snippet => `<div class="wiz-snippet">${escapeHtml(snippet)}</div>`).join('')}
+        </div>
+      `).join('');
+    }
+  }
+
+  async function uploadCustomerFile() {
+    const fileInput = document.getElementById('customerFileInput');
+    const notes = document.getElementById('customerFileNotes').value.trim();
+    if (!fileInput.files.length) {
+      alert('Vælg en fil først.');
+      return;
+    }
+
+    const formData = new FormData();
+    const customerId = document.getElementById('selectedCustomerId').value;
+    if (customerId) {
+      formData.append('customer_id', customerId);
+    }
+    formData.append('notes', notes);
+    formData.append('file', fileInput.files[0]);
+    document.getElementById('uploadStatus').textContent = 'Uploader...';
+
+    const response = await fetch('/api/v1/internet-connections/customer-documents/upload', {
+      method: 'POST',
+      body: formData,
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      document.getElementById('uploadStatus').textContent = 'Upload fejlede.';
+      alert(payload.detail || 'Upload fejlede');
+      return;
+    }
+
+    document.getElementById('uploadStatus').textContent = payload.message || `Uploadet: ${payload.filename || fileInput.files[0].name} · ${payload.segment_count || 0} blokke indekseret`;
+    localUploadedDocuments.unshift({
+      document_id: payload.document_id,
+      original_filename: payload.filename || fileInput.files[0].name,
+      mime_type: fileInput.files[0].type || 'text/plain',
+      file_size: fileInput.files[0].size || 0,
+      notes,
+      segment_count: payload.segment_count || 0,
+      created_at: new Date().toISOString(),
+    });
+    fileInput.value = '';
+    document.getElementById('customerFileNotes').value = '';
+    await loadWizardContext();
+  }
+
+  document.getElementById('customerSearchInput').addEventListener('input', () => {
+    clearTimeout(customerSearchTimer);
+    customerSearchTimer = setTimeout(onCustomerInputChanged, 250);
+  });
+
+  document.getElementById('customerSearchInput').addEventListener('change', onCustomerInputChanged);
+  document.getElementById('queryInput').addEventListener('keydown', (event) => {
+    if (event.key === 'Enter') {
+      event.preventDefault();
+      loadWizardContext();
+    }
+  });
+
+  loadWizardContext();
+</script>
+{% endblock %}
diff --git a/app/modules/sag/templates/detail.html b/app/modules/sag/templates/detail.html
index 5a1a752..7b8964f 100644
--- a/app/modules/sag/templates/detail.html
+++ b/app/modules/sag/templates/detail.html
@@ -7544,6 +7544,7 @@
                             <div class="d-flex justify-content-end mb-3">
                                 <div class="fw-semibold">Total: <span id="subscriptionItemsTotal">0,00 kr</span></div>
                             </div>
+                            <div id="subscriptionProvisioningStatus" class="alert alert-light border d-none mb-3"></div>
                             <div class="d-flex flex-wrap gap-2" id="subscriptionActions"></div>
                         </div>
 
@@ -7613,8 +7614,9 @@
                                 <textarea class="form-control" id="subscriptionNotesInput" rows="2"></textarea>
                             </div>
                             <div class="col-12">
-                                <button type="button" class="btn btn-primary" onclick="createSubscription()">
-                                    <i class="bi bi-plus-circle me-1"></i>Opret abonnement
+                                <div id="subscriptionCreateHint" class="alert alert-info d-none mb-3"></div>
+                                <button type="button" class="btn btn-primary" id="subscriptionCreateButton" onclick="createSubscription()">
+                                    <i class="bi bi-plus-circle me-1"></i><span id="subscriptionCreateButtonLabel">Opret abonnement</span>
                                 </button>
                             </div>
                         </form>
@@ -7670,6 +7672,26 @@
                                 <label class="form-label">Kort beskrivelse</label>
                                 <input type="text" class="form-control" id="subscriptionProductDescription">
                             </div>
+                            <div class="col-12">
+                                <label class="form-label">Netværksprodukt</label>
+                                <select class="form-select" id="subscriptionProductNetworkKind">
+                                    <option value="">Ingen provisioning</option>
+                                    <option value="internet_access">Internet adgang</option>
+                                    <option value="ip_allocation">IP-allokering</option>
+                                </select>
+                            </div>
+                            <div class="col-6">
+                                <label class="form-label">Download Mbps</label>
+                                <input type="number" class="form-control" id="subscriptionProductDownloadMbps" min="1" step="1">
+                            </div>
+                            <div class="col-6">
+                                <label class="form-label">Upload Mbps</label>
+                                <input type="number" class="form-control" id="subscriptionProductUploadMbps" min="1" step="1">
+                            </div>
+                            <div class="col-12">
+                                <label class="form-label">IP prefix</label>
+                                <input type="number" class="form-control" id="subscriptionProductIpPrefix" min="1" max="32" placeholder="fx 30 for /30">
+                            </div>
                         </div>
                     </form>
                 </div>
@@ -7683,6 +7705,43 @@
         </div>
     </div>
 
+    <div class="modal fade" id="subscriptionProvisioningModal" tabindex="-1" aria-hidden="true">
+        <div class="modal-dialog modal-lg modal-dialog-scrollable">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title"><i class="bi bi-hdd-network me-2"></i>Netværksprovisionering</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                </div>
+                <div class="modal-body">
+                    <div id="subscriptionProvisioningAlert" class="alert alert-info d-none mb-3"></div>
+                    <div id="subscriptionProvisioningCurrent" class="alert alert-secondary d-none mb-3"></div>
+                    <div class="mb-3">
+                        <label class="form-label">BMC hovedforbindelse *</label>
+                        <select class="form-select" id="subscriptionProvisioningHeadSelect"></select>
+                        <div class="form-text" id="subscriptionProvisioningHeadHint">Vælg eksisterende BMC-adresse/hovedforbindelse.</div>
+                    </div>
+                    <div class="row g-3 mb-3">
+                        <div class="col-md-6">
+                            <label class="form-label">Internetprodukt</label>
+                            <select class="form-select" id="subscriptionProvisioningInternetItem"></select>
+                        </div>
+                        <div class="col-md-6">
+                            <label class="form-label">Adresse</label>
+                            <div class="form-control bg-light" id="subscriptionProvisioningAddress">-</div>
+                        </div>
+                    </div>
+                    <div id="subscriptionProvisioningIpRanges"></div>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-outline-secondary" data-bs-dismiss="modal">Luk</button>
+                    <button type="button" class="btn btn-primary" onclick="saveSubscriptionProvisioning()">
+                        <i class="bi bi-check2-circle me-1"></i>Gem provisioning
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+
     <!-- Reminders Tab -->
     <div class="tab-pane fade" id="reminders" role="tabpanel" tabindex="0" data-module="reminders" data-has-content="unknown" style="display:none;">
         <div class="row g-3">
@@ -14242,6 +14301,8 @@
         let currentSubscription = null;
         let subscriptionProducts = [];
         let lastCreatedSubscriptionProductId = null;
+        let subscriptionProvisioningData = null;
+        let subscriptionProvisioningAutoPrompted = false;
 
         function formatSubscriptionInterval(interval) {
             const map = {
@@ -14323,6 +14384,7 @@
             }
             populateSubscriptionProductSelects();
             updateSubscriptionLineTotals();
+            refreshSubscriptionCreateState();
         }
 
         function populateSubscriptionProductSelects() {
@@ -14336,6 +14398,7 @@
                     option.textContent = product.name;
                     option.dataset.salesPrice = product.sales_price ?? '';
                     option.dataset.description = product.short_description ?? '';
+                    option.dataset.attributes = JSON.stringify(product.attributes_json ?? {});
                     select.appendChild(option);
                 });
                 if (currentValue) {
@@ -14347,6 +14410,41 @@
             lastCreatedSubscriptionProductId = null;
         }
 
+        function selectedSubscriptionNeedsProvisioning() {
+            const body = document.getElementById('subscriptionLineItemsBody');
+            if (!body) return false;
+            return Array.from(body.querySelectorAll('.subscriptionProductSelect')).some(select => {
+                if (!select.value) return false;
+                const option = select.options[select.selectedIndex];
+                if (!option?.dataset?.attributes) return false;
+                try {
+                    const attrs = JSON.parse(option.dataset.attributes);
+                    const kind = attrs?.network?.kind;
+                    return kind === 'internet_access' || kind === 'ip_allocation';
+                } catch (e) {
+                    return false;
+                }
+            });
+        }
+
+        function refreshSubscriptionCreateState() {
+            const hint = document.getElementById('subscriptionCreateHint');
+            const label = document.getElementById('subscriptionCreateButtonLabel');
+            const needsProvisioning = selectedSubscriptionNeedsProvisioning();
+            if (hint) {
+                if (needsProvisioning) {
+                    hint.classList.remove('d-none');
+                    hint.textContent = "Dette abonnement kræver netværksprovisionering. Efter oprettelse åbnes valg af BMC-adresse og IP-range.";
+                } else {
+                    hint.classList.add('d-none');
+                    hint.textContent = '';
+                }
+            }
+            if (label) {
+                label.textContent = needsProvisioning ? "Opret abonnement og vælg IP'er" : 'Opret abonnement';
+            }
+        }
+
         function applySubscriptionProduct(select) {
             const row = select.closest('tr');
             if (!row) return;
@@ -14365,6 +14463,7 @@
                 unitPriceInput.value = salesPrice;
             }
             updateSubscriptionLineTotals();
+            refreshSubscriptionCreateState();
         }
 
         function addSubscriptionLine() {
@@ -14388,6 +14487,7 @@
             body.appendChild(row);
             populateSubscriptionProductSelects();
             updateSubscriptionLineTotals();
+            refreshSubscriptionCreateState();
         }
 
         function removeSubscriptionLine(button) {
@@ -14402,6 +14502,7 @@
                 row.remove();
             }
             updateSubscriptionLineTotals();
+            refreshSubscriptionCreateState();
         }
 
         function updateSubscriptionLineTotals() {
@@ -14475,13 +14576,28 @@
         }
 
         async function createSubscriptionProduct() {
+            const networkKind = document.getElementById('subscriptionProductNetworkKind').value || null;
+            const downloadMbps = parseInt(document.getElementById('subscriptionProductDownloadMbps').value || '', 10);
+            const uploadMbps = parseInt(document.getElementById('subscriptionProductUploadMbps').value || '', 10);
+            const ipPrefix = parseInt(document.getElementById('subscriptionProductIpPrefix').value || '', 10);
+            const attributes = {};
+            if (networkKind) {
+                attributes.network = {
+                    kind: networkKind,
+                    download_mbps: Number.isFinite(downloadMbps) ? downloadMbps : null,
+                    upload_mbps: Number.isFinite(uploadMbps) ? uploadMbps : null,
+                    speed_mbps: Number.isFinite(downloadMbps) && Number.isFinite(uploadMbps) ? Math.max(downloadMbps, uploadMbps) : null,
+                    ip_prefix_length: Number.isFinite(ipPrefix) ? ipPrefix : null
+                };
+            }
             const payload = {
                 name: document.getElementById('subscriptionProductName').value.trim(),
                 type: document.getElementById('subscriptionProductType').value.trim() || null,
                 status: document.getElementById('subscriptionProductStatus').value,
                 sales_price: document.getElementById('subscriptionProductSalesPrice').value || null,
                 billing_period: document.getElementById('subscriptionProductBillingPeriod').value || null,
-                short_description: document.getElementById('subscriptionProductDescription').value.trim() || null
+                short_description: document.getElementById('subscriptionProductDescription').value.trim() || null,
+                attributes_json: networkKind ? attributes : null
             };
 
             if (!payload.name) {
@@ -14508,6 +14624,200 @@
             updateSubscriptionLineTotals();
         }
 
+        function renderSubscriptionProvisioningStatus(subscription) {
+            const statusEl = document.getElementById('subscriptionProvisioningStatus');
+            if (!statusEl) return;
+            const provisioning = subscription?.network_provisioning;
+            if (!provisioning?.requires_provisioning) {
+                subscriptionProvisioningAutoPrompted = false;
+                statusEl.classList.add('d-none');
+                statusEl.innerHTML = '';
+                return;
+            }
+
+            statusEl.classList.remove('d-none');
+            const internetCount = provisioning.internet_items?.length || 0;
+            const ipCount = provisioning.ip_items?.length || 0;
+            const stateText = provisioning.is_provisioned
+                ? `Provisioneret paa forbindelse #${provisioning.existing_connection_id}`
+                : 'Mangler provisioning';
+            statusEl.innerHTML = `
+                <div class="d-flex flex-wrap justify-content-between gap-2 align-items-center">
+                    <div>
+                        <strong>Netværksflow</strong><br>
+                        <span class="text-muted">${stateText}. Internetlinjer: ${internetCount}. IP-produkter: ${ipCount}.</span>
+                    </div>
+                    <button class="btn btn-sm btn-outline-primary" onclick="openSubscriptionProvisioningModal()">
+                        <i class="bi bi-hdd-network me-1"></i>${provisioning.is_provisioned ? 'Opdater provisioning' : 'Provisioner nu'}
+                    </button>
+                </div>
+            `;
+
+            if (!provisioning.is_provisioned && !subscriptionProvisioningAutoPrompted) {
+                subscriptionProvisioningAutoPrompted = true;
+                setTimeout(() => openSubscriptionProvisioningModal(), 250);
+            }
+        }
+
+        function renderSubscriptionProvisioningModal() {
+            const headSelect = document.getElementById('subscriptionProvisioningHeadSelect');
+            const internetSelect = document.getElementById('subscriptionProvisioningInternetItem');
+            const ipRangesWrap = document.getElementById('subscriptionProvisioningIpRanges');
+            const addressEl = document.getElementById('subscriptionProvisioningAddress');
+            const alertEl = document.getElementById('subscriptionProvisioningAlert');
+            const currentEl = document.getElementById('subscriptionProvisioningCurrent');
+            if (!headSelect || !internetSelect || !ipRangesWrap || !addressEl || !alertEl || !currentEl) return;
+
+            const data = subscriptionProvisioningData;
+            const provisioning = data?.network_provisioning;
+            const heads = data?.shared_heads || [];
+            const currentConnection = data?.existing_connection;
+
+            alertEl.classList.remove('d-none', 'alert-danger');
+            alertEl.classList.add('alert-info');
+            alertEl.innerHTML = provisioning?.requires_provisioning
+                ? 'Vaelg delt BMC-hovedforbindelse og reserver de noedvendige IP-ranges paa adressen.'
+                : 'Dette abonnement kraever ikke netvaerksprovisionering.';
+
+            if (currentConnection) {
+                const currentRanges = (data.current_allocated_ranges || []).map(range => range.cidr).join(', ') || 'Ingen IP-ranges';
+                currentEl.classList.remove('d-none');
+                currentEl.innerHTML = `<strong>Eksisterende forbindelse:</strong> #${currentConnection.id} · ${currentConnection.name || '-'}<br><span class="text-muted">${currentConnection.address || '-'} · ${currentRanges}</span>`;
+            } else {
+                currentEl.classList.add('d-none');
+                currentEl.innerHTML = '';
+            }
+
+            headSelect.innerHTML = heads.map(head => `
+                <option value="${head.id}">
+                    ${head.name || 'Hovedforbindelse'} · ${head.address || 'Ingen adresse'}${head.available_matching_range_count ? ` · ${head.available_matching_range_count} ledige ranges` : ''}
+                </option>
+            `).join('');
+            if (!heads.length) {
+                alertEl.classList.remove('alert-info');
+                alertEl.classList.add('alert-danger');
+                alertEl.innerHTML = 'Ingen delte BMC-hovedforbindelser med ledig kapacitet matcher abonnementet endnu.';
+                headSelect.innerHTML = '<option value="">Ingen ledige hovedforbindelser</option>';
+                addressEl.textContent = '-';
+                ipRangesWrap.innerHTML = '<div class="alert alert-light border mb-0">Tilfoej eller frigiv kapacitet paa en delt hovedforbindelse foerst.</div>';
+                return;
+            }
+
+            const internetItems = provisioning?.internet_items || [];
+            const selectedInternetId = provisioning?.primary_internet_item?.subscription_item_id || internetItems[0]?.subscription_item_id || '';
+            if (internetItems.length) {
+                internetSelect.innerHTML = internetItems.map(item => `
+                    <option value="${item.subscription_item_id}" ${String(item.subscription_item_id) === String(selectedInternetId) ? 'selected' : ''}>
+                        ${item.description || item.product_name}${item.download_mbps || item.upload_mbps ? ` · ${item.download_mbps || '-'} / ${item.upload_mbps || '-'} Mbps` : ''}
+                    </option>
+                `).join('');
+                internetSelect.disabled = internetItems.length <= 1;
+            } else {
+                internetSelect.innerHTML = '<option value="">Ingen dedikeret internetlinje</option>';
+                internetSelect.disabled = true;
+            }
+
+            const selectedHeadId = parseInt(headSelect.value || currentConnection?.parent_id || heads[0]?.id || '', 10);
+            if (Number.isFinite(selectedHeadId)) {
+                headSelect.value = String(selectedHeadId);
+            }
+            const selectedHead = heads.find(head => Number(head.id) === Number(headSelect.value));
+            addressEl.textContent = selectedHead?.address || '-';
+
+            const ipItems = provisioning?.ip_items || [];
+            if (!ipItems.length) {
+                ipRangesWrap.innerHTML = '<div class="alert alert-light border mb-0">Ingen IP-produktlinjer paa abonnementet.</div>';
+                return;
+            }
+
+            const ranges = selectedHead?.available_matching_ranges || [];
+            ipRangesWrap.innerHTML = ipItems.map(item => {
+                const matchingOptions = ranges
+                    .filter(range => !item.ip_prefix_length || Number(range.prefix_length) === Number(item.ip_prefix_length));
+                return `
+                <div class="card border-0 bg-light mb-2">
+                    <div class="card-body py-3">
+                        <div class="fw-semibold mb-1">${item.description || item.product_name}</div>
+                        <div class="small text-muted mb-2">Kraever /${item.ip_prefix_length || '?'} fra den valgte BMC-adresse.</div>
+                        <select class="form-select subscriptionProvisioningRangeSelect" data-item-id="${item.subscription_item_id}">
+                            <option value="">Vaelg ledigt range</option>
+                            ${matchingOptions
+                                .map(range => `<option value="${range.id}">${range.cidr} · ${range.name || 'Range'} · ${range.available_addresses} ledige IP'er</option>`)
+                                .join('')}
+                        </select>
+                        ${matchingOptions.length ? '' : '<div class="small text-danger mt-2">Ingen ledige ranges i den størrelse på denne hovedforbindelse.</div>'}
+                    </div>
+                </div>
+            `}).join('');
+        }
+
+        async function openSubscriptionProvisioningModal() {
+            if (!currentSubscription?.id) return;
+            try {
+                const res = await fetch(`/api/v1/internet-connections/subscriptions/${currentSubscription.id}/provisioning`);
+                if (!res.ok) {
+                    const error = await res.json();
+                    throw new Error(error.detail || 'Kunne ikke hente provisioning-data');
+                }
+                subscriptionProvisioningData = await res.json();
+                renderSubscriptionProvisioningModal();
+                const headSelect = document.getElementById('subscriptionProvisioningHeadSelect');
+                if (headSelect) {
+                    headSelect.onchange = () => renderSubscriptionProvisioningModal();
+                }
+                new bootstrap.Modal(document.getElementById('subscriptionProvisioningModal')).show();
+            } catch (e) {
+                alert(e.message || e);
+            }
+        }
+
+        async function saveSubscriptionProvisioning() {
+            if (!currentSubscription?.id || !subscriptionProvisioningData) return;
+            const headSelect = document.getElementById('subscriptionProvisioningHeadSelect');
+            const internetSelect = document.getElementById('subscriptionProvisioningInternetItem');
+            const rangeSelects = Array.from(document.querySelectorAll('.subscriptionProvisioningRangeSelect'));
+
+            const sharedConnectionId = parseInt(headSelect?.value || '', 10);
+            if (!Number.isFinite(sharedConnectionId)) {
+                alert('Vaelg en BMC hovedforbindelse');
+                return;
+            }
+
+            const ipAllocations = [];
+            for (const select of rangeSelects) {
+                const subscriptionItemId = parseInt(select.dataset.itemId || '', 10);
+                const rangeId = parseInt(select.value || '', 10);
+                if (!Number.isFinite(subscriptionItemId) || !Number.isFinite(rangeId)) {
+                    alert('Vaelg et ledigt range til alle IP-produktlinjer');
+                    return;
+                }
+                ipAllocations.push({
+                    subscription_item_id: subscriptionItemId,
+                    range_id: rangeId
+                });
+            }
+
+            try {
+                const res = await fetch(`/api/v1/internet-connections/subscriptions/${currentSubscription.id}/provision`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        shared_connection_id: sharedConnectionId,
+                        internet_item_id: internetSelect?.value ? parseInt(internetSelect.value, 10) : null,
+                        ip_allocations: ipAllocations
+                    })
+                });
+                if (!res.ok) {
+                    const error = await res.json();
+                    throw new Error(error.detail || 'Kunne ikke gemme provisioning');
+                }
+                bootstrap.Modal.getInstance(document.getElementById('subscriptionProvisioningModal'))?.hide();
+                await loadSubscriptionForCase();
+            } catch (e) {
+                alert(e.message || e);
+            }
+        }
+
         function renderSubscription(subscription) {
             currentSubscription = subscription;
             const empty = document.getElementById('subscriptionEmpty');
@@ -14566,6 +14876,8 @@
                 itemsTotal.textContent = formatSubscriptionCurrency(subscription.price || 0);
             }
 
+            renderSubscriptionProvisioningStatus(subscription);
+
             const actions = document.getElementById('subscriptionActions');
             if (!actions) return;
 
@@ -14579,6 +14891,9 @@
             if (subscription.status !== 'cancelled') {
                 buttons.push(`<button class="btn btn-sm btn-outline-danger" onclick="updateSubscriptionStatus('cancelled')"><i class="bi bi-x-circle me-1"></i>Opsig</button>`);
             }
+            if (subscription?.network_provisioning?.requires_provisioning) {
+                buttons.push(`<button class="btn btn-sm btn-outline-primary" onclick="openSubscriptionProvisioningModal()"><i class="bi bi-hdd-network me-1"></i>${subscription.network_provisioning.is_provisioned ? 'Opdater provisioning' : 'Provisioner forbindelse'}</button>`);
+            }
             actions.innerHTML = buttons.join(' ');
         }
 
@@ -14649,6 +14964,9 @@
 
                 const subscription = await res.json();
                 renderSubscription(subscription);
+                if (subscription?.requires_network_provisioning) {
+                    await openSubscriptionProvisioningModal();
+                }
             } catch (e) {
                 alert(e.message || e);
             }
diff --git a/app/modules/sag/templates/detail_v3.html b/app/modules/sag/templates/detail_v3.html
index 512d0ea..1df5c0e 100644
--- a/app/modules/sag/templates/detail_v3.html
+++ b/app/modules/sag/templates/detail_v3.html
@@ -8451,6 +8451,40 @@
                             <div class="d-flex justify-content-end mb-3">
                                 <div class="fw-semibold">Total: <span id="subscriptionItemsTotal">0,00 kr</span></div>
                             </div>
+                            <div id="subscriptionProvisioningStatus" class="alert alert-light border d-none mb-3"></div>
+                            <div id="subscriptionProvisioningInline" class="card border-primary-subtle bg-light d-none mb-3">
+                                <div class="card-body">
+                                    <div class="d-flex justify-content-between align-items-center mb-3">
+                                        <div>
+                                            <div class="fw-semibold">Netværksprovisionering</div>
+                                            <div class="small text-muted">Vælg BMC-hovedforbindelse og reserver IP-range på kladden, før aktivering.</div>
+                                        </div>
+                                    </div>
+                                    <div id="subscriptionProvisioningInlineAlert" class="alert alert-info d-none mb-3"></div>
+                                    <div id="subscriptionProvisioningInlineCurrent" class="alert alert-secondary d-none mb-3"></div>
+                                    <div id="subscriptionProvisioningInlineCompact" class="d-none mb-2"></div>
+                                    <div class="row g-3 mb-3">
+                                        <div class="col-md-6">
+                                            <label class="form-label">BMC hovedforbindelse *</label>
+                                            <select class="form-select" id="subscriptionProvisioningInlineHeadSelect"></select>
+                                        </div>
+                                        <div class="col-md-6">
+                                            <label class="form-label">Internetprodukt</label>
+                                            <select class="form-select" id="subscriptionProvisioningInlineInternetItem"></select>
+                                        </div>
+                                        <div class="col-12">
+                                            <label class="form-label">Adresse</label>
+                                            <div class="form-control bg-white" id="subscriptionProvisioningInlineAddress">-</div>
+                                        </div>
+                                    </div>
+                                    <div id="subscriptionProvisioningInlineRanges"></div>
+                                    <div class="d-flex gap-2 mt-3">
+                                        <button type="button" class="btn btn-primary" id="subscriptionProvisioningInlineSaveBtn" onclick="saveSubscriptionProvisioningInline()">
+                                            <i class="bi bi-check2-circle me-1"></i>Gem provisioning
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
                             <div class="d-flex flex-wrap gap-2" id="subscriptionActions"></div>
                         </div>
 
@@ -8520,9 +8554,15 @@
                                 <textarea class="form-control" id="subscriptionNotesInput" rows="2"></textarea>
                             </div>
                             <div class="col-12">
-                                <button type="button" class="btn btn-primary" onclick="createSubscription()">
-                                    <i class="bi bi-plus-circle me-1"></i>Opret abonnement
-                                </button>
+                                <div id="subscriptionCreateHint" class="alert alert-info d-none mb-3"></div>
+                                <div class="d-flex flex-wrap gap-2">
+                                    <button type="button" class="btn btn-primary" id="subscriptionCreateButton" onclick="createSubscription()">
+                                        <i class="bi bi-plus-circle me-1"></i><span id="subscriptionCreateButtonLabel">Opret abonnement</span>
+                                    </button>
+                                    <button type="button" class="btn btn-outline-secondary d-none" id="subscriptionCancelEditButton" onclick="cancelSubscriptionEdit()">
+                                        <i class="bi bi-arrow-counterclockwise me-1"></i>Annuller redigering
+                                    </button>
+                                </div>
                             </div>
                         </form>
                     </div>
@@ -8577,6 +8617,26 @@
                                 <label class="form-label">Kort beskrivelse</label>
                                 <input type="text" class="form-control" id="subscriptionProductDescription">
                             </div>
+                            <div class="col-12">
+                                <label class="form-label">Netværksprodukt</label>
+                                <select class="form-select" id="subscriptionProductNetworkKind">
+                                    <option value="">Ingen provisioning</option>
+                                    <option value="internet_access">Internet adgang</option>
+                                    <option value="ip_allocation">IP-allokering</option>
+                                </select>
+                            </div>
+                            <div class="col-6">
+                                <label class="form-label">Download Mbps</label>
+                                <input type="number" class="form-control" id="subscriptionProductDownloadMbps" min="1" step="1">
+                            </div>
+                            <div class="col-6">
+                                <label class="form-label">Upload Mbps</label>
+                                <input type="number" class="form-control" id="subscriptionProductUploadMbps" min="1" step="1">
+                            </div>
+                            <div class="col-12">
+                                <label class="form-label">IP prefix</label>
+                                <input type="number" class="form-control" id="subscriptionProductIpPrefix" min="1" max="32" placeholder="fx 30 for /30">
+                            </div>
                         </div>
                     </form>
                 </div>
@@ -16361,6 +16421,8 @@
         let currentSubscription = null;
         let subscriptionProducts = [];
         let lastCreatedSubscriptionProductId = null;
+        let subscriptionProvisioningData = null;
+        let subscriptionEditMode = false;
 
         function formatSubscriptionInterval(interval) {
             const map = {
@@ -16442,6 +16504,81 @@
             }
             populateSubscriptionProductSelects();
             updateSubscriptionLineTotals();
+            refreshSubscriptionCreateState();
+        }
+
+        function renderSubscriptionEditForm(subscription) {
+            const empty = document.getElementById('subscriptionEmpty');
+            const form = document.getElementById('subscriptionCreateForm');
+            const details = document.getElementById('subscriptionDetails');
+            if (empty) empty.classList.add('d-none');
+            if (form) form.classList.remove('d-none');
+            if (details) details.classList.add('d-none');
+
+            document.getElementById('subscriptionIntervalInput').value = subscription.billing_interval || 'monthly';
+            document.getElementById('subscriptionBillingDayInput').value = subscription.billing_day || 1;
+            document.getElementById('subscriptionStartDateInput').value = subscription.start_date || '';
+            document.getElementById('subscriptionNotesInput').value = subscription.notes || '';
+
+            const body = document.getElementById('subscriptionLineItemsBody');
+            if (!body) return;
+            const items = subscription.line_items || [];
+            body.innerHTML = items.map(item => `
+                <tr>
+                    <td>
+                        <select class="form-select form-select-sm subscriptionProductSelect" onchange="applySubscriptionProduct(this)">
+                            <option value="">Vælg produkt</option>
+                        </select>
+                    </td>
+                    <td><input type="text" class="form-control form-control-sm" placeholder="Beskrivelse" value="${(item.description || '').replace(/"/g, '&quot;')}"></td>
+                    <td><input type="number" class="form-control form-control-sm" min="0.01" step="0.01" value="${item.quantity ?? 1}" oninput="updateSubscriptionLineTotals()"></td>
+                    <td><input type="number" class="form-control form-control-sm" min="0" step="0.01" value="${item.unit_price ?? 0}" oninput="updateSubscriptionLineTotals()"></td>
+                    <td class="text-end"><span class="subscriptionLineTotal">0,00 kr</span></td>
+                    <td class="text-end">
+                        <button type="button" class="btn btn-sm btn-outline-danger" onclick="removeSubscriptionLine(this)"><i class="bi bi-x"></i></button>
+                    </td>
+                </tr>
+            `).join('') || `
+                <tr>
+                    <td>
+                        <select class="form-select form-select-sm subscriptionProductSelect" onchange="applySubscriptionProduct(this)">
+                            <option value="">Vælg produkt</option>
+                        </select>
+                    </td>
+                    <td><input type="text" class="form-control form-control-sm" placeholder="Beskrivelse"></td>
+                    <td><input type="number" class="form-control form-control-sm" min="0.01" step="0.01" value="1" oninput="updateSubscriptionLineTotals()"></td>
+                    <td><input type="number" class="form-control form-control-sm" min="0" step="0.01" value="0" oninput="updateSubscriptionLineTotals()"></td>
+                    <td class="text-end"><span class="subscriptionLineTotal">0,00 kr</span></td>
+                    <td class="text-end">
+                        <button type="button" class="btn btn-sm btn-outline-danger" onclick="removeSubscriptionLine(this)"><i class="bi bi-x"></i></button>
+                    </td>
+                </tr>
+            `;
+            populateSubscriptionProductSelects();
+            Array.from(body.querySelectorAll('tr')).forEach((row, index) => {
+                const select = row.querySelector('.subscriptionProductSelect');
+                const item = items[index];
+                if (select && item?.product_id) {
+                    select.value = String(item.product_id);
+                }
+            });
+            updateSubscriptionLineTotals();
+            refreshSubscriptionCreateState();
+        }
+
+        function startSubscriptionEdit() {
+            if (!currentSubscription) return;
+            subscriptionEditMode = true;
+            renderSubscriptionEditForm(currentSubscription);
+        }
+
+        function cancelSubscriptionEdit() {
+            subscriptionEditMode = false;
+            if (currentSubscription?.id) {
+                renderSubscription(currentSubscription);
+            } else {
+                showSubscriptionCreateForm();
+            }
         }
 
         function populateSubscriptionProductSelects() {
@@ -16455,6 +16592,7 @@
                     option.textContent = product.name;
                     option.dataset.salesPrice = product.sales_price ?? '';
                     option.dataset.description = product.short_description ?? '';
+                    option.dataset.attributes = JSON.stringify(product.attributes_json ?? {});
                     select.appendChild(option);
                 });
                 if (currentValue) {
@@ -16466,6 +16604,51 @@
             lastCreatedSubscriptionProductId = null;
         }
 
+        function selectedSubscriptionNeedsProvisioning() {
+            const body = document.getElementById('subscriptionLineItemsBody');
+            if (!body) return false;
+            return Array.from(body.querySelectorAll('.subscriptionProductSelect')).some(select => {
+                if (!select.value) return false;
+                const option = select.options[select.selectedIndex];
+                if (!option?.dataset?.attributes) return false;
+                try {
+                    const attrs = JSON.parse(option.dataset.attributes);
+                    const kind = attrs?.network?.kind;
+                    return kind === 'internet_access' || kind === 'ip_allocation';
+                } catch (e) {
+                    return false;
+                }
+            });
+        }
+
+        function refreshSubscriptionCreateState() {
+            const hint = document.getElementById('subscriptionCreateHint');
+            const label = document.getElementById('subscriptionCreateButtonLabel');
+            const cancelButton = document.getElementById('subscriptionCancelEditButton');
+            const needsProvisioning = selectedSubscriptionNeedsProvisioning();
+            if (hint) {
+                if (needsProvisioning) {
+                    hint.classList.remove('d-none');
+                    hint.textContent = subscriptionEditMode
+                        ? "Denne kladde kræver netværksprovisionering. Gem kladden og vælg BMC-adresse og IP-range i boksen under abonnementet."
+                        : "Dette abonnement kræver netværksprovisionering. Efter oprettelse bruger du boksen under abonnementet til at vælge BMC-adresse og IP-range.";
+                } else {
+                    hint.classList.add('d-none');
+                    hint.textContent = '';
+                }
+            }
+            if (label) {
+                if (subscriptionEditMode) {
+                    label.textContent = needsProvisioning ? "Gem kladde og vælg IP'er" : 'Gem kladde';
+                } else {
+                    label.textContent = needsProvisioning ? "Opret abonnement og vælg IP'er" : 'Opret abonnement';
+                }
+            }
+            if (cancelButton) {
+                cancelButton.classList.toggle('d-none', !subscriptionEditMode);
+            }
+        }
+
         function applySubscriptionProduct(select) {
             const row = select.closest('tr');
             if (!row) return;
@@ -16484,6 +16667,7 @@
                 unitPriceInput.value = salesPrice;
             }
             updateSubscriptionLineTotals();
+            refreshSubscriptionCreateState();
         }
 
         function addSubscriptionLine() {
@@ -16507,6 +16691,7 @@
             body.appendChild(row);
             populateSubscriptionProductSelects();
             updateSubscriptionLineTotals();
+            refreshSubscriptionCreateState();
         }
 
         function removeSubscriptionLine(button) {
@@ -16521,6 +16706,7 @@
                 row.remove();
             }
             updateSubscriptionLineTotals();
+            refreshSubscriptionCreateState();
         }
 
         function updateSubscriptionLineTotals() {
@@ -16594,13 +16780,28 @@
         }
 
         async function createSubscriptionProduct() {
+            const networkKind = document.getElementById('subscriptionProductNetworkKind').value || null;
+            const downloadMbps = parseInt(document.getElementById('subscriptionProductDownloadMbps').value || '', 10);
+            const uploadMbps = parseInt(document.getElementById('subscriptionProductUploadMbps').value || '', 10);
+            const ipPrefix = parseInt(document.getElementById('subscriptionProductIpPrefix').value || '', 10);
+            const attributes = {};
+            if (networkKind) {
+                attributes.network = {
+                    kind: networkKind,
+                    download_mbps: Number.isFinite(downloadMbps) ? downloadMbps : null,
+                    upload_mbps: Number.isFinite(uploadMbps) ? uploadMbps : null,
+                    speed_mbps: Number.isFinite(downloadMbps) && Number.isFinite(uploadMbps) ? Math.max(downloadMbps, uploadMbps) : null,
+                    ip_prefix_length: Number.isFinite(ipPrefix) ? ipPrefix : null
+                };
+            }
             const payload = {
                 name: document.getElementById('subscriptionProductName').value.trim(),
                 type: document.getElementById('subscriptionProductType').value.trim() || null,
                 status: document.getElementById('subscriptionProductStatus').value,
                 sales_price: document.getElementById('subscriptionProductSalesPrice').value || null,
                 billing_period: document.getElementById('subscriptionProductBillingPeriod').value || null,
-                short_description: document.getElementById('subscriptionProductDescription').value.trim() || null
+                short_description: document.getElementById('subscriptionProductDescription').value.trim() || null,
+                attributes_json: networkKind ? attributes : null
             };
 
             if (!payload.name) {
@@ -16627,8 +16828,398 @@
             updateSubscriptionLineTotals();
         }
 
+        function renderSubscriptionProvisioningStatus(subscription) {
+            const statusEl = document.getElementById('subscriptionProvisioningStatus');
+            if (!statusEl) return;
+            const provisioning = subscription?.network_provisioning;
+            if (!provisioning?.requires_provisioning) {
+                statusEl.classList.add('d-none');
+                statusEl.innerHTML = '';
+                return;
+            }
+
+            statusEl.classList.remove('d-none');
+            const internetCount = provisioning.internet_items?.length || 0;
+            const ipCount = provisioning.ip_items?.length || 0;
+            const stateText = provisioning.is_provisioned
+                ? `Provisioneret paa forbindelse #${provisioning.existing_connection_id}`
+                : 'Mangler provisioning';
+            statusEl.innerHTML = `
+                <div class="d-flex flex-wrap justify-content-between gap-2 align-items-center">
+                    <div>
+                        <strong>Netværksflow</strong><br>
+                        <span class="text-muted">${stateText}. Internetlinjer: ${internetCount}. IP-produkter: ${ipCount}.</span>
+                    </div>
+                </div>
+            `;
+        }
+
+        function parseProvisioningRangeSelection(value) {
+            const raw = String(value || '').trim();
+            if (!raw) return null;
+            const [rangeIdRaw, requestedCidrRaw] = raw.split('|');
+            const rangeId = parseInt(rangeIdRaw || '', 10);
+            if (!Number.isFinite(rangeId)) return null;
+            return {
+                range_id: rangeId,
+                requested_cidr: requestedCidrRaw ? requestedCidrRaw.trim() : null
+            };
+        }
+
+        function cidrPrefixLength(cidr) {
+            const raw = String(cidr || '').trim();
+            const match = raw.match(/\/(\d{1,2})$/);
+            return match ? parseInt(match[1], 10) : null;
+        }
+
+        function ipToInt(ip) {
+            return String(ip || '').split('.').reduce((acc, octet) => {
+                const value = parseInt(octet, 10);
+                return (acc << 8) + (Number.isFinite(value) ? value : 0);
+            }, 0) >>> 0;
+        }
+
+        function intToIp(intValue) {
+            return [
+                (intValue >>> 24) & 255,
+                (intValue >>> 16) & 255,
+                (intValue >>> 8) & 255,
+                intValue & 255
+            ].join('.');
+        }
+
+        function subnetCandidatesFromRange(range, requiredPrefixes) {
+            if (!requiredPrefixes?.length) return [];
+            if (range.customer_id != null) return [];
+            if (!range.is_fully_available) return [];
+            const cidr = String(range.cidr || '').trim();
+            const [baseIp] = cidr.split('/');
+            const sourcePrefix = cidrPrefixLength(cidr);
+            if (!baseIp || !Number.isFinite(sourcePrefix)) return [];
+
+            const baseInt = ipToInt(baseIp);
+            const sourceSize = 2 ** (32 - sourcePrefix);
+            const seen = new Set();
+            const results = [];
+
+            for (const prefix of requiredPrefixes) {
+                const requestedPrefix = Number(prefix);
+                if (!Number.isFinite(requestedPrefix) || requestedPrefix < sourcePrefix) continue;
+
+                if (requestedPrefix === sourcePrefix) {
+                    const key = `${range.id}|${cidr}`;
+                    if (seen.has(key)) continue;
+                    seen.add(key);
+                    results.push({
+                        ...range,
+                        range_id: Number(range.id),
+                        source_range_id: Number(range.id),
+                        source_cidr: cidr,
+                        requested_cidr: cidr,
+                        is_derived_candidate: false
+                    });
+                    continue;
+                }
+
+                const subnetSize = 2 ** (32 - requestedPrefix);
+                for (let offset = 0; offset < sourceSize; offset += subnetSize) {
+                    const requestedCidr = `${intToIp((baseInt + offset) >>> 0)}/${requestedPrefix}`;
+                    const key = `${range.id}|${requestedCidr}`;
+                    if (seen.has(key)) continue;
+                    seen.add(key);
+                    const usableHosts = subnetSize > 1 ? Math.max(subnetSize - 2, 0) : subnetSize;
+                    results.push({
+                        ...range,
+                        id: `${range.id}:${requestedCidr}`,
+                        range_id: Number(range.id),
+                        source_range_id: Number(range.id),
+                        source_cidr: cidr,
+                        requested_cidr: requestedCidr,
+                        cidr: requestedCidr,
+                        name: `${range.name || 'Range'} -> ${requestedCidr}`,
+                        prefix_length: requestedPrefix,
+                        total_hosts: subnetSize,
+                        usable_hosts: usableHosts,
+                        total_addresses: usableHosts,
+                        available_addresses: usableHosts,
+                        reserved_addresses: 0,
+                        in_use_addresses: 0,
+                        used_addresses: 0,
+                        is_fully_available: true,
+                        is_derived_candidate: true
+                    });
+                }
+            }
+            return results;
+        }
+
+        async function loadAllSharedProvisioningHeads(requiredPrefixes) {
+            const res = await fetch('/api/v1/internet-connections?shared_only=true');
+            if (!res.ok) return [];
+            const heads = await res.json();
+            const sharedHeads = Array.isArray(heads)
+                ? heads.filter(head => head && String(head.allocation_model || '').toLowerCase() === 'shared' && !head.parent_id)
+                : [];
+
+            const enriched = await Promise.all(sharedHeads.map(async (head) => {
+                try {
+                    const rangesRes = await fetch(`/api/v1/internet-connections/${head.id}/ip-ranges`);
+                    const ranges = rangesRes.ok ? await rangesRes.json() : [];
+                    const availableMatchingRanges = Array.isArray(ranges)
+                        ? ranges.flatMap(range => subnetCandidatesFromRange(range, requiredPrefixes || []))
+                        : [];
+                    return {
+                        ...head,
+                        available_matching_ranges: availableMatchingRanges,
+                        available_matching_range_count: availableMatchingRanges.length
+                    };
+                } catch (e) {
+                    return {
+                        ...head,
+                        available_matching_ranges: [],
+                        available_matching_range_count: 0
+                    };
+                }
+            }));
+
+            return enriched.sort((a, b) => String(a.address || a.name || '').localeCompare(String(b.address || b.name || ''), 'da'));
+        }
+
+        function renderSubscriptionProvisioningInline(data, forcedHeadId = null) {
+            const panel = document.getElementById('subscriptionProvisioningInline');
+            const alertEl = document.getElementById('subscriptionProvisioningInlineAlert');
+            const currentEl = document.getElementById('subscriptionProvisioningInlineCurrent');
+            const compactEl = document.getElementById('subscriptionProvisioningInlineCompact');
+            const headSelect = document.getElementById('subscriptionProvisioningInlineHeadSelect');
+            const internetSelect = document.getElementById('subscriptionProvisioningInlineInternetItem');
+            const addressEl = document.getElementById('subscriptionProvisioningInlineAddress');
+            const rangesWrap = document.getElementById('subscriptionProvisioningInlineRanges');
+            const saveBtn = document.getElementById('subscriptionProvisioningInlineSaveBtn');
+            if (!panel || !alertEl || !currentEl || !compactEl || !headSelect || !internetSelect || !addressEl || !rangesWrap || !saveBtn) return;
+
+            const provisioning = data?.network_provisioning;
+            if (!provisioning?.requires_provisioning) {
+                panel.classList.add('d-none');
+                return;
+            }
+            panel.classList.remove('d-none');
+
+            const heads = data.shared_heads || [];
+            const currentConnection = data.existing_connection;
+            const currentAllocatedRanges = Array.isArray(data.current_allocated_ranges) ? data.current_allocated_ranges : [];
+            const isProvisioned = Boolean(provisioning?.is_provisioned && currentConnection);
+            alertEl.classList.remove('d-none', 'alert-danger');
+            alertEl.classList.add('alert-info');
+            alertEl.textContent = isProvisioned
+                ? 'Denne kladde er allerede provisioneret. Den valgte hovedforbindelse og IP-allokering er låst her.'
+                : 'Vælg den delte BMC-hovedforbindelse og et ledigt range til IP-produktet.';
+
+            if (currentConnection) {
+                const currentRanges = currentAllocatedRanges.map(range => range.cidr).join(', ') || 'Ingen IP-ranges';
+                currentEl.classList.remove('d-none');
+                currentEl.innerHTML = `<strong>Eksisterende provisionering:</strong> #${currentConnection.id} · ${currentConnection.name || '-'} · ${currentRanges}`;
+            } else {
+                currentEl.classList.add('d-none');
+                currentEl.innerHTML = '';
+            }
+
+            if (!heads.length) {
+                alertEl.classList.remove('alert-info');
+                alertEl.classList.add('alert-danger');
+                alertEl.textContent = 'Ingen delte BMC-hovedforbindelser med ledig kapacitet matcher abonnementet endnu.';
+                headSelect.innerHTML = '<option value="">Ingen ledige hovedforbindelser</option>';
+                internetSelect.innerHTML = '<option value="">Ingen internetlinje</option>';
+                addressEl.textContent = '-';
+                rangesWrap.innerHTML = '<div class="alert alert-light border mb-0">Der findes ingen ledige ranges i den størrelse abonnementet kræver.</div>';
+                return;
+            }
+
+            headSelect.innerHTML = heads.map(head => `
+                <option value="${head.id}">
+                    ${head.name || 'Hovedforbindelse'} · ${head.address || 'Ingen adresse'}${head.available_matching_range_count ? ` · ${head.available_matching_range_count} ledige ranges` : ''}
+                </option>
+            `).join('');
+
+            const internetItems = provisioning.internet_items || [];
+            const selectedInternetId = provisioning.primary_internet_item?.subscription_item_id || internetItems[0]?.subscription_item_id || '';
+            if (internetItems.length) {
+                internetSelect.innerHTML = internetItems.map(item => `
+                    <option value="${item.subscription_item_id}" ${String(item.subscription_item_id) === String(selectedInternetId) ? 'selected' : ''}>
+                        ${item.description || item.product_name}
+                    </option>
+                `).join('');
+            } else {
+                internetSelect.innerHTML = '<option value="">Ingen dedikeret internetlinje</option>';
+            }
+
+            const desiredHeadId = forcedHeadId ?? headSelect.value;
+            const selectedHead = heads.find(head => String(head.id) === String(desiredHeadId)) || heads[0];
+            if (selectedHead) {
+                headSelect.value = String(selectedHead.id);
+                addressEl.textContent = selectedHead.address || '-';
+            }
+            if (isProvisioned && currentConnection?.parent_id) {
+                headSelect.value = String(currentConnection.parent_id);
+            }
+
+            const ipItems = provisioning.ip_items || [];
+            const ranges = selectedHead?.available_matching_ranges || [];
+            const remainingCurrentRanges = [...currentAllocatedRanges];
+            rangesWrap.innerHTML = ipItems.map(item => {
+                let currentRange = null;
+                if (remainingCurrentRanges.length) {
+                    const matchingIndex = remainingCurrentRanges.findIndex((range) => (
+                        !item.ip_prefix_length || Number(range.prefix_length) === Number(item.ip_prefix_length)
+                    ));
+                    if (matchingIndex >= 0) {
+                        currentRange = remainingCurrentRanges.splice(matchingIndex, 1)[0];
+                    } else {
+                        currentRange = remainingCurrentRanges.shift();
+                    }
+                }
+                const matchingOptions = ranges
+                    .filter(range => !item.ip_prefix_length || Number(range.prefix_length) === Number(item.ip_prefix_length));
+                const currentValue = currentRange ? `${currentRange.id}|${currentRange.cidr}` : '';
+                return `
+                <div class="card border-0 bg-white mb-2">
+                    <div class="card-body py-3">
+                        <div class="fw-semibold mb-1">${item.description || item.product_name}</div>
+                        <div class="small text-muted mb-2">Kræver /${item.ip_prefix_length || '?'}.</div>
+                        <select class="form-select subscriptionProvisioningInlineRangeSelect" data-item-id="${item.subscription_item_id}" ${isProvisioned ? 'disabled' : ''}>
+                            <option value="">${isProvisioned ? 'Ingen range valgt' : 'Vælg ledigt range'}</option>
+                            ${currentRange ? `<option value="${currentValue}" selected>${currentRange.cidr} · Allerede valgt</option>` : ''}
+                            ${matchingOptions
+                                .filter(range => `${range.range_id || range.id}|${range.requested_cidr || range.cidr}` !== currentValue)
+                                .map(range => `<option value="${range.range_id || range.id}|${range.requested_cidr || range.cidr}">${range.cidr} · ${range.name || 'Range'} · ${range.available_addresses} ledige IP'er${range.is_derived_candidate ? ' · delblok' : ''}</option>`)
+                                .join('')}
+                        </select>
+                        ${isProvisioned
+                            ? '<div class="small text-muted mt-2">IP-range er allerede reserveret på abonnementet.</div>'
+                            : (matchingOptions.length ? '' : '<div class="small text-danger mt-2">Ingen ledige ranges i den størrelse på denne hovedforbindelse.</div>')}
+                    </div>
+                </div>
+            `}).join('');
+
+            if (isProvisioned) {
+                const compactHead = selectedHead?.name || 'Ukendt hovedforbindelse';
+                const compactProduct = currentConnection?.name || internetItems.find(item => String(item.subscription_item_id) === String(selectedInternetId))?.description || '-';
+                const compactRanges = currentAllocatedRanges.map(range => range.cidr).join(', ') || 'Ingen IP-range';
+                compactEl.classList.remove('d-none');
+                compactEl.innerHTML = `
+                    <div class="d-flex align-items-center justify-content-between gap-3 border rounded-3 bg-white px-3 py-2">
+                        <div class="text-truncate">
+                            <span class="fw-semibold">Provisionering:</span>
+                            <span>#${currentConnection.id}</span>
+                            <span class="text-muted">·</span>
+                            <span>${compactHead}</span>
+                            <span class="text-muted">·</span>
+                            <span>${compactProduct}</span>
+                            <span class="text-muted">·</span>
+                            <span>${compactRanges}</span>
+                        </div>
+                        <a href="/economy/internet-connections/${currentConnection.id}" class="btn btn-sm btn-outline-secondary flex-shrink-0" title="Rediger forbindelse">
+                            <i class="bi bi-pencil"></i>
+                        </a>
+                    </div>
+                `;
+            } else {
+                compactEl.classList.add('d-none');
+                compactEl.innerHTML = '';
+            }
+
+            headSelect.disabled = isProvisioned;
+            internetSelect.disabled = isProvisioned;
+            saveBtn.classList.toggle('d-none', isProvisioned);
+            alertEl.classList.toggle('d-none', isProvisioned);
+            currentEl.classList.toggle('d-none', isProvisioned);
+            headSelect.closest('.row')?.classList.toggle('d-none', isProvisioned);
+            rangesWrap.classList.toggle('d-none', isProvisioned);
+            headSelect.onchange = isProvisioned ? null : () => renderSubscriptionProvisioningInline(data, headSelect.value);
+        }
+
+        async function loadSubscriptionProvisioningInline() {
+            if (!currentSubscription?.id) return;
+            try {
+                const res = await fetch(`/api/v1/internet-connections/subscriptions/${currentSubscription.id}/provisioning`);
+                if (!res.ok) {
+                    return;
+                }
+                subscriptionProvisioningData = await res.json();
+                const requiredPrefixes = subscriptionProvisioningData?.network_provisioning?.required_ip_prefixes || [];
+                const allHeads = await loadAllSharedProvisioningHeads(requiredPrefixes);
+                if (allHeads.length) {
+                    const byId = new Map();
+                    (allHeads || []).forEach(head => byId.set(Number(head.id), head));
+                    (subscriptionProvisioningData.shared_heads || []).forEach(head => {
+                        const existing = byId.get(Number(head.id)) || {};
+                        byId.set(Number(head.id), {
+                            ...existing,
+                            ...head,
+                            available_matching_ranges: head.available_matching_ranges || existing.available_matching_ranges || [],
+                            available_matching_range_count: head.available_matching_range_count ?? existing.available_matching_range_count ?? 0
+                        });
+                    });
+                    subscriptionProvisioningData.shared_heads = Array.from(byId.values());
+                }
+                renderSubscriptionProvisioningInline(subscriptionProvisioningData);
+            } catch (e) {
+                console.error('Error loading inline provisioning:', e);
+            }
+        }
+
+        async function saveSubscriptionProvisioningInline() {
+            if (!currentSubscription?.id || !subscriptionProvisioningData) return;
+            if (subscriptionProvisioningData?.network_provisioning?.is_provisioned) {
+                alert('Denne provisionering er allerede gemt. Opret eller rediger forbindelsen direkte, hvis den skal ændres.');
+                return;
+            }
+            const headSelect = document.getElementById('subscriptionProvisioningInlineHeadSelect');
+            const internetSelect = document.getElementById('subscriptionProvisioningInlineInternetItem');
+            const rangeSelects = Array.from(document.querySelectorAll('.subscriptionProvisioningInlineRangeSelect'));
+            const sharedConnectionId = parseInt(headSelect?.value || '', 10);
+            if (!Number.isFinite(sharedConnectionId)) {
+                alert('Vælg en BMC hovedforbindelse');
+                return;
+            }
+
+            const ipAllocations = [];
+            for (const select of rangeSelects) {
+                const subscriptionItemId = parseInt(select.dataset.itemId || '', 10);
+                const parsedRange = parseProvisioningRangeSelection(select.value);
+                if (!Number.isFinite(subscriptionItemId) || !parsedRange) {
+                    alert('Vælg et ledigt range til alle IP-produktlinjer');
+                    return;
+                }
+                ipAllocations.push({
+                    subscription_item_id: subscriptionItemId,
+                    range_id: parsedRange.range_id,
+                    requested_cidr: parsedRange.requested_cidr
+                });
+            }
+
+            try {
+                const res = await fetch(`/api/v1/internet-connections/subscriptions/${currentSubscription.id}/provision`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        shared_connection_id: sharedConnectionId,
+                        internet_item_id: internetSelect?.value ? parseInt(internetSelect.value, 10) : null,
+                        ip_allocations: ipAllocations
+                    })
+                });
+                if (!res.ok) {
+                    const error = await res.json();
+                    throw new Error(error.detail || 'Kunne ikke gemme provisioning');
+                }
+                await loadSubscriptionForCase();
+            } catch (e) {
+                alert(e.message || e);
+            }
+        }
+
         function renderSubscription(subscription) {
             currentSubscription = subscription;
+            subscriptionEditMode = false;
             const empty = document.getElementById('subscriptionEmpty');
             const form = document.getElementById('subscriptionCreateForm');
             const details = document.getElementById('subscriptionDetails');
@@ -16685,10 +17276,21 @@
                 itemsTotal.textContent = formatSubscriptionCurrency(subscription.price || 0);
             }
 
+            renderSubscriptionProvisioningStatus(subscription);
+            if (subscription?.network_provisioning?.requires_provisioning) {
+                loadSubscriptionProvisioningInline();
+            } else {
+                const panel = document.getElementById('subscriptionProvisioningInline');
+                if (panel) panel.classList.add('d-none');
+            }
+
             const actions = document.getElementById('subscriptionActions');
             if (!actions) return;
 
             const buttons = [];
+            if (subscription.status === 'draft') {
+                buttons.push(`<button class="btn btn-sm btn-outline-secondary" onclick="startSubscriptionEdit()"><i class="bi bi-pencil-square me-1"></i>Rediger kladde</button>`);
+            }
             if (subscription.status === 'draft' || subscription.status === 'paused') {
                 buttons.push(`<button class="btn btn-sm btn-success" onclick="updateSubscriptionStatus('active')"><i class="bi bi-play-circle me-1"></i>Aktiver</button>`);
             }
@@ -16748,17 +17350,26 @@
             }
 
             try {
-                const res = await fetch('/api/v1/sag-subscriptions', {
-                    method: 'POST',
+                const isEditing = subscriptionEditMode && currentSubscription?.id;
+                const url = isEditing
+                    ? `/api/v1/sag-subscriptions/${currentSubscription.id}`
+                    : '/api/v1/sag-subscriptions';
+                const method = isEditing ? 'PATCH' : 'POST';
+                const payload = {
+                    billing_interval: billingInterval,
+                    billing_day: billingDay,
+                    start_date: startDate,
+                    notes: notes || null,
+                    line_items: lineItems
+                };
+                if (!isEditing) {
+                    payload.sag_id = subscriptionCaseId;
+                }
+
+                const res = await fetch(url, {
+                    method,
                     headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        sag_id: subscriptionCaseId,
-                        billing_interval: billingInterval,
-                        billing_day: billingDay,
-                        start_date: startDate,
-                        notes: notes || null,
-                        line_items: lineItems
-                    })
+                    body: JSON.stringify(payload)
                 });
 
                 if (!res.ok) {
@@ -16768,6 +17379,9 @@
 
                 const subscription = await res.json();
                 renderSubscription(subscription);
+                if (subscription?.requires_network_provisioning) {
+                    await loadSubscriptionProvisioningInline();
+                }
             } catch (e) {
                 alert(e.message || e);
             }
diff --git a/app/modules/telefoni/backend/router.py b/app/modules/telefoni/backend/router.py
index 6835057..9219868 100644
--- a/app/modules/telefoni/backend/router.py
+++ b/app/modules/telefoni/backend/router.py
@@ -34,6 +34,50 @@ logger = logging.getLogger(__name__)
 router = APIRouter()
 
 
+def _resolve_sms_recipient_from_contact(number: Optional[str], contact_id: Optional[int]) -> Optional[str]:
+    raw_number = str(number or "").strip()
+    if not raw_number or not contact_id:
+        return raw_number or None
+
+    contact = execute_query_single(
+        """
+        SELECT id, phone, mobile
+        FROM contacts
+        WHERE id = %s
+        LIMIT 1
+        """,
+        (contact_id,),
+    )
+    if not contact:
+        return raw_number
+
+    requested_normalized = normalize_e164(raw_number) or raw_number
+    requested_digits = digits_only(requested_normalized)
+    requested_suffix = requested_digits[-8:] if len(requested_digits) >= 8 else None
+
+    candidates: list[str] = []
+    for candidate_raw in (contact.get("mobile"), contact.get("phone")):
+        candidate_normalized = normalize_e164(candidate_raw)
+        if candidate_normalized and candidate_normalized not in candidates:
+            candidates.append(candidate_normalized)
+
+    if not candidates:
+        return raw_number
+
+    if requested_normalized in candidates:
+        return requested_normalized
+
+    # If UI has reduced an international number to a Danish-looking 8-digit suffix,
+    # prefer a stored international contact number that ends with the same suffix.
+    if requested_suffix and (len(requested_digits) == 8 or requested_digits.startswith("45")):
+        for candidate in candidates:
+            candidate_digits = digits_only(candidate)
+            if candidate_digits.endswith(requested_suffix) and not candidate_digits.startswith("45"):
+                return candidate
+
+    return raw_number
+
+
 @router.post("/sms/send")
 async def send_sms(payload: SmsSendRequest, request: Request):
     user_id = getattr(request.state, "user_id", None)
@@ -48,7 +92,8 @@ async def send_sms(payload: SmsSendRequest, request: Request):
         raise HTTPException(status_code=400, detail="SMS skal knyttes til en kontakt")
 
     try:
-        result = SmsService.send_sms(payload.to, payload.message, payload.sender)
+        recipient_number = _resolve_sms_recipient_from_contact(payload.to, contact_id)
+        result = SmsService.send_sms(recipient_number, payload.message, payload.sender)
         execute_query(
             """
             INSERT INTO sms_messages (kontakt_id, bruger_id, recipient, sender, message, status, provider_response)
@@ -57,7 +102,7 @@ async def send_sms(payload: SmsSendRequest, request: Request):
             (
                 contact_id,
                 user_id,
-                result.get("recipient") or payload.to,
+                result.get("recipient") or recipient_number or payload.to,
                 payload.sender or settings.SMS_SENDER,
                 payload.message,
                 "sent",
@@ -700,9 +745,7 @@ async def list_calls(
             t.bruger_id,
             t.direction,
             t.ekstern_nummer,
-            COALESCE(
-                NULLIF(TRIM(t.ekstern_nummer), '')
-            ) AS display_number,
+            NULLIF(TRIM(t.ekstern_nummer), '') AS display_number,
             t.intern_extension,
             t.kontakt_id,
             t.sag_id,
@@ -744,13 +787,13 @@ async def list_calls(
         repaired = normalize_external_number(display_raw)
         if repaired:
             row["display_number"] = repaired
-    if rows:
-        return rows
 
-    # Fallback: legacy mission call history (read-only rows) for environments
-    # where historical calls were stored before telefoni_opkald was populated.
+    # Legacy mission call history (read-only rows) for environments where
+    # some historical calls were stored before telefoni_opkald was populated.
+    # Do not use this as an all-or-nothing fallback; merge it so mixed datasets
+    # still show every visible call on the telefoni page.
     if user_id is not None:
-        return []
+        return rows
 
     legacy_where = []
     legacy_params = []
@@ -803,9 +846,34 @@ async def list_calls(
     except Exception:
         legacy_rows = []
 
+    if not legacy_rows:
+        return rows
+
+    existing_callids = {
+        str(row.get("callid") or "").strip()
+        for row in rows
+        if str(row.get("callid") or "").strip()
+    }
+
+    merged_rows = list(rows)
+    for legacy_row in legacy_rows:
+        legacy_callid = str(legacy_row.get("callid") or "").strip()
+        if legacy_callid and legacy_callid in existing_callids:
+            continue
+        display_raw = legacy_row.get("display_number") or legacy_row.get("ekstern_nummer")
+        repaired = normalize_external_number(display_raw)
+        if repaired:
+            legacy_row["display_number"] = repaired
+        merged_rows.append(legacy_row)
+
+    merged_rows.sort(
+        key=lambda row: row.get("started_at") or row.get("created_at") or "",
+        reverse=True,
+    )
+    paged_rows = merged_rows[offset : offset + limit]
     if without_case:
-        return [r for r in legacy_rows if not r.get("sag_id")]
-    return legacy_rows
+        return [r for r in paged_rows if not r.get("sag_id")]
+    return paged_rows
 
 
 @router.patch("/telefoni/calls/{call_id}")
diff --git a/app/modules/telefoni/frontend/views.py b/app/modules/telefoni/frontend/views.py
index 18aa365..20f5813 100644
--- a/app/modules/telefoni/frontend/views.py
+++ b/app/modules/telefoni/frontend/views.py
@@ -20,9 +20,7 @@ async def telefoni_log_page(request: Request):
             SELECT
                 t.id,
                 t.direction,
-                COALESCE(
-                    NULLIF(TRIM(t.ekstern_nummer), '')
-                ) AS display_number,
+                NULLIF(TRIM(t.ekstern_nummer), '') AS display_number,
                 t.started_at,
                 t.duration_sec,
                 t.ended_at,
diff --git a/app/modules/telefoni/templates/log.html b/app/modules/telefoni/templates/log.html
index 3e4cb72..6cc68d8 100644
--- a/app/modules/telefoni/templates/log.html
+++ b/app/modules/telefoni/templates/log.html
@@ -271,14 +271,11 @@ function normalizeDisplayNumber(value) {
         if (digits.length >= 10 && digits.slice(0, 2) === '45') {
             return `+${digits.slice(0, 10)}`;
         }
-        if (digits.length >= 8 && /[2-9]/.test(digits.charAt(0))) {
-            return `+45${digits.slice(0, 8)}`;
-        }
         if (digits.length >= 10 && digits.slice(-10).startsWith('45')) {
             return `+${digits.slice(-10)}`;
         }
-        if (digits.length >= 8) {
-            return `+45${digits.slice(-8)}`;
+        if (digits.length >= 9) {
+            return `+${digits.slice(-15)}`;
         }
     }
 
@@ -286,7 +283,7 @@ function normalizeDisplayNumber(value) {
         return digits.length >= 9 ? `+${digits}` : raw;
     }
 
-    if (digits.length === 8) return `+45${digits}`;
+    if (digits.length === 8) return raw;
     if (digits.length === 10 && digits.startsWith('45')) return `+${digits}`;
     if (digits.length >= 9) return `+${digits}`;
     return raw;
@@ -1215,13 +1212,6 @@ document.addEventListener('DOMContentLoaded', async () => {
     document.getElementById('filterTo').addEventListener('change', loadCalls);
     document.getElementById('filterWithoutCase').addEventListener('change', loadCalls);
 
-    // Keep SSR rows on first paint when they exist; avoid replacing visible data
-    // with an empty state due to transient API/auth/cache issues in production.
-    if (hasExistingCallRows(telefoniRows)) {
-        console.warn('Telefoni: springer initial auto-refresh over, SSR-rækker vises');
-        return;
-    }
-
     await loadCalls({ preserveOnEmpty: true, skipLoadingState: true });
 });
 </script>
diff --git a/app/products/backend/router.py b/app/products/backend/router.py
index dbb7450..f276dd2 100644
--- a/app/products/backend/router.py
+++ b/app/products/backend/router.py
@@ -668,6 +668,7 @@ async def list_products(
                 serial_number_required,
                 asset_required,
                 rental_asset_enabled,
+                attributes_json,
                 image_url
             FROM products
             {where_clause}
diff --git a/app/services/invoice2data_service.py b/app/services/invoice2data_service.py
index 03a1850..5d163a0 100644
--- a/app/services/invoice2data_service.py
+++ b/app/services/invoice2data_service.py
@@ -59,7 +59,300 @@ class Invoice2DataService:
         
         logger.warning("⚠️ No template matched")
         return None
-    
+
+    def _parse_amount(self, value: Any, decimal_separator: str = ",", thousands_separator: str = ".") -> Optional[float]:
+        if value is None:
+            return None
+        if isinstance(value, (int, float)):
+            return float(value)
+
+        cleaned = re.sub(r"\s+", "", str(value).strip())
+        if not cleaned:
+            return None
+
+        if thousands_separator in cleaned and decimal_separator in cleaned:
+            cleaned = cleaned.replace(thousands_separator, "").replace(decimal_separator, ".")
+        elif thousands_separator in cleaned:
+            cleaned = cleaned.replace(thousands_separator, "")
+        elif decimal_separator == "," and "," in cleaned:
+            cleaned = cleaned.replace(",", ".")
+
+        try:
+            return float(cleaned)
+        except ValueError:
+            return None
+
+    def _parse_date_value(self, value: Any, date_formats: Optional[List[str]] = None) -> Optional[str]:
+        if value is None:
+            return None
+
+        raw = str(value).strip()
+        if not raw:
+            return None
+
+        normalized = raw
+        replacements = {
+            "januar": "January",
+            "februar": "February",
+            "marts": "March",
+            "april": "April",
+            "maj": "May",
+            "juni": "June",
+            "juli": "July",
+            "august": "August",
+            "september": "September",
+            "oktober": "October",
+            "november": "November",
+            "december": "December",
+        }
+        for da_name, en_name in replacements.items():
+            normalized = re.sub(rf"\b{da_name}\b", en_name, normalized, flags=re.IGNORECASE)
+
+        candidates = date_formats or [
+            "%d.%m.%Y",
+            "%d-%m-%Y",
+            "%d/%m-%Y",
+            "%d. %B %Y",
+            "%d. %B %Y.",
+            "%d. %B %Y",
+            "%d. %B %Y",
+        ]
+        normalized = re.sub(r"\s+", " ", normalized).strip()
+
+        for candidate in candidates:
+            try:
+                return datetime.strptime(normalized, candidate).strftime("%Y-%m-%d")
+            except ValueError:
+                continue
+
+        return None
+
+    def _is_globalconnect_noise_line(self, line: str) -> bool:
+        compact = re.sub(r"\s+", " ", str(line or "")).strip()
+        if not compact:
+            return True
+        if len(compact) > 140:
+            return True
+        noise_patterns = (
+            r"Skandinaviska Enskilda Banken",
+            r"\bSWIFT-kode\b",
+            r"\bIBAN\b",
+            r"www\.globalconnect\.dk",
+            r"CMsupport@globalconnect\.dk",
+            r"\+45\s*77\s*30\s*30\s*00",
+            r"Faktura\s+BMC Denmark ApS",
+            r"\bBeskrivelse\s+Antal\s+Enhed\s+Enhedspris\s+Beløb\b",
+            r"\bI alt DKK\b",
+            r"\b25%\s+moms\b",
+            r"\bSE/CVR-nr\.?\b",
+            r"\bPBS-nummer\b",
+            r"\bBS Kundenr\.?\b",
+            r"\bDeb\. grp\. nr\.?\b",
+            r"\bBetalingsbetingelser\b",
+            r"\bEfter forfald beregnes rente\b",
+            r"\bTeleydelser uden moms\b",
+            r"\bAdministrations gebyr\b",
+        )
+        return any(re.search(pattern, compact, re.IGNORECASE) for pattern in noise_patterns)
+
+    def _extract_globalconnect(self, text: str, template_name: str, template: Dict[str, Any]) -> Dict[str, Any]:
+        options = template.get("options", {})
+        extracted: Dict[str, Any] = {
+            "template": template_name,
+            "issuer": template.get("issuer"),
+            "country": template.get("country"),
+            "currency": options.get("currency", "DKK"),
+        }
+
+        invoice_number_match = re.search(r"(?:Fakturanr\.?|Kreditnotanr\.?)\s*(\d+)", text, re.IGNORECASE)
+        if invoice_number_match:
+            extracted["invoice_number"] = int(invoice_number_match.group(1))
+
+        if re.search(r"\bKreditnota\b|\bKreditnotanr\.?\b", text, re.IGNORECASE):
+            extracted["document_type"] = "credit_note"
+
+        customer_reference_match = re.search(r"Kundenr\.?\s*([A-Z0-9-]+)", text, re.IGNORECASE)
+        if customer_reference_match:
+            extracted["customer_reference"] = customer_reference_match.group(1).strip()
+
+        invoice_date_match = re.search(r"Bilagsdato\s+([^\n]+)", text, re.IGNORECASE)
+        if invoice_date_match:
+            parsed = self._parse_date_value(invoice_date_match.group(1), ["%d. %B %Y"])
+            if parsed:
+                extracted["invoice_date"] = parsed
+
+        due_date_match = re.search(r"Forfaldsdato\s+([^\n]+)", text, re.IGNORECASE)
+        if due_date_match:
+            parsed = self._parse_date_value(due_date_match.group(1), ["%d. %B %Y"])
+            if parsed:
+                extracted["due_date"] = parsed
+
+        untaxed_match = re.search(r"I\s+alt\s+DKK\s+ekskl\.\s+moms\s+([\d.,]+)", text, re.IGNORECASE)
+        if untaxed_match:
+            extracted["amount_untaxed"] = self._parse_amount(untaxed_match.group(1))
+
+        vat_match = re.search(r"25%\s+moms\s+([\d.,]+)", text, re.IGNORECASE)
+        if vat_match:
+            extracted["vat_amount"] = self._parse_amount(vat_match.group(1))
+
+        total_match = re.search(r"I\s+alt\s+DKK\s+inkl\.\s+moms\s+([\d.,]+)", text, re.IGNORECASE)
+        if total_match:
+            extracted["amount_total"] = self._parse_amount(total_match.group(1))
+
+        cvr_matches = [match.group(1) for match in re.finditer(r"SE/CVR-nr\.\s+(\d{8})", text, re.IGNORECASE)]
+        vendor_cvrs = [cvr for cvr in cvr_matches if cvr != "29522790"]
+        if vendor_cvrs:
+            extracted["vendor_vat"] = vendor_cvrs[0]
+
+        lines: List[Dict[str, Any]] = []
+        current_context: Dict[str, Any] = {}
+        pending_street: Optional[str] = None
+        pending_line_for_continuation: Optional[Dict[str, Any]] = None
+
+        for raw_line in text.splitlines():
+            line = re.sub(r"\s+", " ", raw_line).strip()
+            if not line:
+                continue
+
+            contract_match = re.match(r"Kontrakt:\s*(.+)$", line, re.IGNORECASE)
+            if contract_match:
+                current_context["contract_number"] = contract_match.group(1).strip()
+                pending_line_for_continuation = None
+                continue
+
+            vedr_match = re.match(r"Vedr:\s*(.+)$", line, re.IGNORECASE)
+            if vedr_match:
+                provider_reference = vedr_match.group(1).strip()
+                current_context["provider_reference"] = provider_reference
+                current_context["circuit_id"] = provider_reference
+                pending_line_for_continuation = None
+                continue
+
+            customer_match = re.match(r"Slutkunde:\s*(.+)$", line, re.IGNORECASE)
+            if customer_match:
+                current_context["end_customer_name"] = customer_match.group(1).strip()
+                pending_line_for_continuation = None
+                continue
+
+            period_match = re.match(r"Periode:\s*(\d{2}-\d{2}-\d{4})\s*-\s*(\d{2}-\d{2}-\d{4})", line, re.IGNORECASE)
+            if period_match:
+                current_context["period_start"] = self._parse_date_value(period_match.group(1), ["%d-%m-%Y"])
+                current_context["period_end"] = self._parse_date_value(period_match.group(2), ["%d-%m-%Y"])
+                pending_line_for_continuation = None
+                continue
+
+            cidr_match = re.match(r"(\d{1,3}(?:\.\d{1,3}){3}/\d{1,2})(?:\s+\(([^)]+)\))?$", line)
+            if cidr_match:
+                cidr = cidr_match.group(1)
+                reference = cidr_match.group(2).strip() if cidr_match.group(2) else None
+                if pending_line_for_continuation and "ip" in str(pending_line_for_continuation.get("description") or "").lower():
+                    pending_line_for_continuation["ip_address"] = cidr
+                    if reference:
+                        pending_line_for_continuation["provider_reference"] = reference
+                        pending_line_for_continuation["circuit_id"] = reference
+                current_context["ip_address"] = cidr
+                if reference:
+                    current_context["provider_reference"] = reference
+                    current_context["circuit_id"] = reference
+                continue
+
+            reference_match = re.match(r"((?:NKA|EB|DSL-)[A-Z0-9-]+)$", line, re.IGNORECASE)
+            if reference_match:
+                reference = reference_match.group(1).strip()
+                current_context["provider_reference"] = reference
+                current_context["circuit_id"] = reference
+                if pending_line_for_continuation and not pending_line_for_continuation.get("provider_reference"):
+                    pending_line_for_continuation["provider_reference"] = reference
+                    pending_line_for_continuation["circuit_id"] = reference
+                pending_street = None
+                continue
+
+            street_only_match = re.match(r"(.+?\d+[A-ZÆØÅa-zæøå]?)$", line)
+            if street_only_match and not re.search(r"(?:Fakturanr|Bilagsdato|Forfaldsdato|SE/CVR|Kundenr|Kontrakt|Vedr|Slutkunde|Periode)", line, re.IGNORECASE):
+                postal_hint = re.search(r"\b\d{4}\b", line)
+                if not postal_hint and not re.search(r"\b(?:Gbps|Mbps|Kbps|Måneder|Måned|Stk|pcs)\b", line, re.IGNORECASE):
+                    pending_street = street_only_match.group(1).strip()
+                    continue
+
+            city_line_match = re.match(r"(\d{4})\s+([A-ZÆØÅa-zæøå].+)$", line)
+            if city_line_match and pending_street:
+                postal_code = city_line_match.group(1).strip()
+                city = city_line_match.group(2).strip()
+                current_context["location_street"] = pending_street
+                current_context["location_zip"] = postal_code
+                current_context["location_city"] = city
+                current_context["service_address"] = f"{pending_street}, {postal_code} {city}"
+                if pending_line_for_continuation and not pending_line_for_continuation.get("service_address"):
+                    pending_line_for_continuation["location_street"] = pending_street
+                    pending_line_for_continuation["location_zip"] = postal_code
+                    pending_line_for_continuation["location_city"] = city
+                    pending_line_for_continuation["service_address"] = f"{pending_street}, {postal_code} {city}"
+                pending_street = None
+                continue
+
+            address_match = re.match(r"(.+?)\s+(\d{4})\s+([A-ZÆØÅa-zæøå].+)$", line)
+            if address_match and not re.search(r"(?:Fakturanr|Bilagsdato|Forfaldsdato|SE/CVR)", line, re.IGNORECASE):
+                street = address_match.group(1).strip()
+                postal_code = address_match.group(2).strip()
+                city = address_match.group(3).strip()
+                current_context["location_street"] = street
+                current_context["location_zip"] = postal_code
+                current_context["location_city"] = city
+                current_context["service_address"] = f"{street}, {postal_code} {city}"
+                if pending_line_for_continuation and not pending_line_for_continuation.get("service_address"):
+                    pending_line_for_continuation["location_street"] = street
+                    pending_line_for_continuation["location_zip"] = postal_code
+                    pending_line_for_continuation["location_city"] = city
+                    pending_line_for_continuation["service_address"] = f"{street}, {postal_code} {city}"
+                pending_street = None
+                continue
+
+            line_match = re.match(
+                r"(.+?)\s+(\d+(?:[.,]\d+)?)\s+(Måneder|Måned|Stk\.?|Stk|pcs\.?)\s+([\d.]+,\d{2})\s+([\d.]+,\d{2})$",
+                line,
+                re.IGNORECASE,
+            )
+            if not line_match:
+                if pending_line_for_continuation and not self._is_globalconnect_noise_line(line) and not re.search(
+                    r"(?:I alt DKK|25% moms|SE/CVR|Kundenr\.?|Fakturanr\.?|Bilagsdato|Forfaldsdato)",
+                    line,
+                    re.IGNORECASE,
+                ):
+                    existing = str(pending_line_for_continuation.get("description") or "").strip()
+                    if line.lower() not in existing.lower():
+                        combined = f"{existing} {line}".strip()
+                        pending_line_for_continuation["description"] = combined[:250].strip()
+                continue
+
+            description = line_match.group(1).strip()
+            quantity = self._parse_amount(line_match.group(2))
+            unit = line_match.group(3).strip()
+            unit_price = self._parse_amount(line_match.group(4))
+            line_total = self._parse_amount(line_match.group(5))
+
+            line_data: Dict[str, Any] = {
+                "line_number": len(lines) + 1,
+                "description": description,
+                "quantity": quantity,
+                "unit": unit,
+                "unit_price": unit_price,
+                "line_total": line_total,
+                "customer_reference": extracted.get("customer_reference"),
+            }
+            line_data.update(current_context)
+            lines.append(line_data)
+            pending_line_for_continuation = line_data
+            pending_street = None
+
+            if "ip_address" in current_context:
+                current_context.pop("ip_address", None)
+
+        if lines:
+            extracted["lines"] = lines
+
+        self._validate_amounts(extracted)
+        return extracted
+
     def extract_with_template(self, text: str, template_name: str) -> Dict[str, Any]:
         """
         Extract invoice data using specific template
@@ -68,6 +361,9 @@ class Invoice2DataService:
             raise ValueError(f"Template not found: {template_name}")
         
         template = self.templates[template_name]
+        if template_name == "dk.globalconnect":
+            return self._extract_globalconnect(text, template_name, template)
+
         fields = template.get('fields', {})
         options = template.get('options', {})
         
@@ -113,49 +409,14 @@ class Invoice2DataService:
                     
                     # Convert type
                     if field_type == 'float':
-                        # Handle Danish number format (1.234,56 → 1234.56)
-                        # OR (148,587.98 → 148587.98) - handle both formats
                         decimal_sep = options.get('decimal_separator', ',')
                         thousands_sep = options.get('thousands_separator', '.')
-                        
-                        # Remove all whitespace first (pdf extraction may split numbers across lines)
-                        value = re.sub(r'\s+', '', value)
-                        
-                        # If both separators are present, we can determine the format
-                        # Danish: 148.587,98 (thousands=., decimal=,)
-                        # English: 148,587.98 (thousands=, decimal=.)
-                        if thousands_sep in value and decimal_sep in value:
-                            # Remove thousands separator, then convert decimal separator to .
-                            value = value.replace(thousands_sep, '').replace(decimal_sep, '.')
-                        elif thousands_sep in value:
-                            # Only thousands separator present - just remove it
-                            value = value.replace(thousands_sep, '')
-                        elif decimal_sep in value and decimal_sep == ',':
-                            # Only decimal separator and it's Danish comma - convert to .
-                            value = value.replace(',', '.')
-                        
-                        value = float(value)
+                        value = self._parse_amount(value, decimal_sep, thousands_sep)
                     elif field_type == 'int':
                         value = int(value)
                     elif field_type == 'date':
-                        # Try to parse Danish dates
                         date_formats = options.get('date_formats', ['%B %d, %Y', '%d-%m-%Y'])
-                        
-                        # Danish month names
-                        value = value.replace('januar', 'January').replace('februar', 'February')
-                        value = value.replace('marts', 'March').replace('april', 'April')
-                        value = value.replace('maj', 'May').replace('juni', 'June')
-                        value = value.replace('juli', 'July').replace('august', 'August')
-                        value = value.replace('september', 'September').replace('oktober', 'October')
-                        value = value.replace('november', 'November').replace('december', 'December')
-                        
-                        for date_format in date_formats:
-                            try:
-                                parsed_date = datetime.strptime(value, date_format)
-                                value = parsed_date.strftime('%Y-%m-%d')
-                                break
-                            except ValueError:
-                                continue
+                        value = self._parse_date_value(value, date_formats) or value
                     
                     extracted[field_name] = value
                     logger.debug(f"  ✓ {field_name}: {value}")
@@ -395,6 +656,17 @@ class Invoice2DataService:
             subtotal = total_amount
             if vat_amount is not None:
                 subtotal = total_amount - vat_amount
+
+            validation_details = {
+                'line_sum': round(line_sum, 2),
+                'subtotal': round(subtotal, 2),
+                'difference': round(abs(line_sum - subtotal), 2),
+                'subtotal_matches': abs(line_sum - subtotal) <= 1.0,
+                'vat_amount': round(float(vat_amount), 2) if vat_amount is not None else None,
+                'vat_expected': None,
+                'vat_difference': None,
+                'vat_matches': None,
+            }
             
             # Check if line sum matches subtotal (allow 1 DKK difference for rounding)
             if abs(line_sum - subtotal) > 1.0:
@@ -406,11 +678,16 @@ class Invoice2DataService:
             # Check VAT calculation (25%)
             if vat_amount is not None:
                 expected_vat = subtotal * 0.25
+                validation_details['vat_expected'] = round(expected_vat, 2)
+                validation_details['vat_difference'] = round(abs(vat_amount - expected_vat), 2)
+                validation_details['vat_matches'] = abs(vat_amount - expected_vat) <= 1.0
                 if abs(vat_amount - expected_vat) > 1.0:
                     logger.warning(f"⚠️ VAT validation: VAT {vat_amount:.2f} != 25% of {subtotal:.2f} ({expected_vat:.2f})")
                     extracted['_vat_warning'] = f"Moms ({vat_amount:.2f}) passer ikke med 25% af subtotal ({expected_vat:.2f})"
                 else:
                     logger.info(f"✅ VAT validation: 25% VAT calculation correct ({vat_amount:.2f})")
+
+            extracted['_validation_details'] = validation_details
                     
         except Exception as e:
             logger.warning(f"⚠️ Amount validation failed: {e}")
diff --git a/app/shared/frontend/base.html b/app/shared/frontend/base.html
index 898f339..b93cd01 100644
--- a/app/shared/frontend/base.html
+++ b/app/shared/frontend/base.html
@@ -1000,6 +1000,7 @@
                         <li data-menu-key="menu-okonomi-prepaid"><a class="dropdown-item py-2" href="/prepaid-cards"><i class="bi bi-credit-card-2-front me-2"></i>Prepaid Cards</a></li>
                         <li data-menu-key="menu-okonomi-fixed-price"><a class="dropdown-item py-2" href="/fixed-price-agreements"><i class="bi bi-calendar-check me-2"></i>Fastpris Aftaler</a></li>
                         <li data-menu-key="menu-okonomi-subscriptions"><a class="dropdown-item py-2" href="/subscriptions"><i class="bi bi-repeat me-2"></i>Abonnementer</a></li>
+                        <li data-menu-key="menu-okonomi-internet-connections"><a class="dropdown-item py-2" href="/economy/internet-connections"><i class="bi bi-hdd-network me-2"></i>Internetforbindelser</a></li>
                     </ul>
                 </li>
             </ul>
@@ -1015,6 +1016,7 @@
                         <li data-menu-key="menu-datamigration-employee-log"><a class="dropdown-item py-2" href="/timetracking/employee-log"><i class="bi bi-bar-chart-steps me-2"></i>Medarbejder Log</a></li>
                         <li data-menu-key="menu-datamigration-service-contract-wizard"><a class="dropdown-item py-2" href="/timetracking/service-contract-wizard"><i class="bi bi-diagram-3 me-2"></i>Servicekontrakt Migration</a></li>
                         <li data-menu-key="menu-datamigration-service-contract-report"><a class="dropdown-item py-2" href="/timetracking/service-contract-report"><i class="bi bi-file-earmark-bar-graph me-2"></i>Servicekontrakt Rapport</a></li>
+                        <li data-menu-key="menu-datamigration-internet-wizard-v2"><a class="dropdown-item py-2" href="/data-migration/internet-wizard-v2"><i class="bi bi-hdd-network me-2"></i>Internet Wizard v2</a></li>
                         <li data-menu-key="menu-datamigration-orders"><a class="dropdown-item py-2" href="/timetracking/orders"><i class="bi bi-receipt me-2"></i>Ordrer</a></li>
                         <li data-menu-key="menu-datamigration-customers"><a class="dropdown-item py-2" href="/timetracking/customers"><i class="bi bi-people me-2"></i>Kunder</a></li>
                     </ul>
@@ -1427,7 +1429,7 @@ if (bmcOriginalFetch) {
 <script src="/static/js/task-template-selector.js?v=1.1"></script>
 <script src="/static/js/notifications.js?v=1.0"></script>
 <script src="/static/js/telefoni.js?v=2.4"></script>
-<script src="/static/js/sms.js?v=1.0"></script>
+<script src="/static/js/sms.js?v=1.1"></script>
 <script src="/static/js/bug-report.js?v=1.4"></script>
 <script src="/static/js/bottom-bar.js?v=2.43"></script>
 <script>
@@ -2439,6 +2441,7 @@ if (bmcOriginalFetch) {
         { key: 'menu-datamigration-employee-log', label: 'Data migration: Medarbejder Log' },
         { key: 'menu-datamigration-service-contract-wizard', label: 'Data migration: Servicekontrakt Migration' },
         { key: 'menu-datamigration-service-contract-report', label: 'Data migration: Servicekontrakt Rapport' },
+        { key: 'menu-datamigration-internet-wizard-v2', label: 'Data migration: Internet Wizard v2' },
         { key: 'menu-datamigration-orders', label: 'Data migration: Ordrer' },
         { key: 'menu-datamigration-customers', label: 'Data migration: Kunder' },
     ];
diff --git a/app/subscriptions/backend/router.py b/app/subscriptions/backend/router.py
index 1b2100b..bbc4273 100644
--- a/app/subscriptions/backend/router.py
+++ b/app/subscriptions/backend/router.py
@@ -14,6 +14,7 @@ from datetime import datetime, date, timedelta
 from dateutil.relativedelta import relativedelta
 from fastapi import Request
 from app.services.simplycrm_service import SimplyCRMService
+from app.modules.internet_connections.backend.provisioning_utils import summarize_subscription_network_requirements
 
 logger = logging.getLogger(__name__)
 router = APIRouter()
@@ -26,6 +27,108 @@ ALLOWED_PRICE_CHANGE_STATUSES = {"pending", "approved", "rejected", "applied"}
 ALLOWED_BILLING_INTERVALS = {"daily", "biweekly", "monthly", "quarterly", "yearly"}
 
 
+def _load_subscription_line_items(subscription_id: int) -> List[Dict[str, Any]]:
+    rows = execute_query(
+        """
+        SELECT
+            i.id,
+            i.line_no,
+            i.product_id,
+            p.name AS product_name,
+            p.type AS product_type,
+            p.attributes_json,
+            i.description,
+            i.quantity,
+            i.unit_price,
+            i.line_total,
+            i.period_from,
+            i.period_to,
+            i.requires_serial_number,
+            i.serial_number,
+            i.billing_blocked,
+            i.billing_block_reason
+        FROM sag_subscription_items i
+        LEFT JOIN products p ON p.id = i.product_id
+        WHERE i.subscription_id = %s
+        ORDER BY i.line_no ASC, i.id ASC
+        """,
+        (subscription_id,),
+    ) or []
+    return [dict(row) for row in rows]
+
+
+def _attach_network_provisioning(subscription: Dict[str, Any]) -> Dict[str, Any]:
+    line_items = subscription.get("line_items") or []
+    provisioning = summarize_subscription_network_requirements(line_items)
+    existing_connection = execute_query_single(
+        """
+        SELECT id, parent_id
+        FROM internet_connections_connections
+        WHERE subscription_id = %s
+          AND deleted_at IS NULL
+        ORDER BY id ASC
+        LIMIT 1
+        """,
+        (subscription.get("id"),),
+    )
+    provisioning["existing_connection_id"] = existing_connection.get("id") if existing_connection else None
+    provisioning["is_provisioned"] = bool(existing_connection)
+    subscription["requires_network_provisioning"] = provisioning["requires_provisioning"]
+    subscription["network_provisioning"] = provisioning
+    return subscription
+
+
+def _load_subscription_with_context(subscription_id: int) -> Dict[str, Any]:
+    subscription = execute_query_single(
+        """
+        SELECT
+            s.id,
+            s.subscription_number,
+            s.sag_id,
+            sg.titel AS sag_title,
+            s.customer_id,
+            c.name AS customer_name,
+            s.product_name,
+            s.billing_interval,
+            s.billing_direction,
+            s.advance_months,
+            s.first_full_period_start,
+            s.billing_day,
+            s.price,
+            s.start_date,
+            s.end_date,
+            s.next_invoice_date,
+            s.period_start,
+            s.binding_months,
+            s.binding_start_date,
+            s.binding_end_date,
+            s.binding_group_key,
+            s.notice_period_days,
+            s.billing_blocked,
+            s.billing_block_reason,
+            s.invoice_merge_key,
+            s.price_change_case_id,
+            s.renewal_case_id,
+            s.status,
+            s.notes,
+            s.cancelled_at,
+            s.cancellation_reason,
+            s.created_at,
+            s.updated_at
+        FROM sag_subscriptions s
+        LEFT JOIN sag_sager sg ON sg.id = s.sag_id
+        LEFT JOIN customers c ON c.id = s.customer_id
+        WHERE s.id = %s
+        """,
+        (subscription_id,),
+    )
+    if not subscription:
+        raise HTTPException(status_code=404, detail="Subscription not found")
+    subscription = dict(subscription)
+    subscription["line_items"] = _load_subscription_line_items(subscription_id)
+    return _attach_network_provisioning(subscription)
+
+
 def _staging_status_with_mapping(status: str, has_customer: bool) -> str:
     if status == "approved":
         return "approved"
@@ -239,26 +342,8 @@ async def get_subscription_by_sag(sag_id: int, allow_missing: bool = Query(False
             if allow_missing:
                 return {"subscription": None, "line_items": []}
             raise HTTPException(status_code=404, detail="Subscription not found")
-        items = execute_query(
-            """
-            SELECT
-                i.id,
-                i.line_no,
-                i.product_id,
-                p.name AS product_name,
-                i.description,
-                i.quantity,
-                i.unit_price,
-                i.line_total
-            FROM sag_subscription_items i
-            LEFT JOIN products p ON p.id = i.product_id
-            WHERE i.subscription_id = %s
-            ORDER BY i.line_no ASC, i.id ASC
-            """,
-            (subscription["id"],)
-        )
-        subscription["line_items"] = items or []
-        return subscription
+        subscription["line_items"] = _load_subscription_line_items(int(subscription["id"]))
+        return _attach_network_provisioning(subscription)
     except HTTPException:
         raise
     except Exception as e:
@@ -579,8 +664,8 @@ async def create_subscription(payload: Dict[str, Any]):
 
                 conn.commit()
 
-            subscription["line_items"] = cleaned_items
-            return subscription
+            subscription["line_items"] = _load_subscription_line_items(int(subscription["id"]))
+            return _attach_network_provisioning(dict(subscription))
         finally:
             release_db_connection(conn)
     except HTTPException:
@@ -594,78 +679,7 @@ async def create_subscription(payload: Dict[str, Any]):
 async def get_subscription(subscription_id: int):
     """Get a single subscription by ID with all details."""
     try:
-        query = """
-            SELECT
-                s.id,
-                s.subscription_number,
-                s.sag_id,
-                sg.titel AS sag_title,
-                s.customer_id,
-                c.name AS customer_name,
-                s.product_name,
-                s.billing_interval,
-                s.billing_direction,
-                s.advance_months,
-                s.first_full_period_start,
-                s.billing_day,
-                s.price,
-                s.start_date,
-                s.end_date,
-                s.next_invoice_date,
-                s.period_start,
-                s.binding_months,
-                s.binding_start_date,
-                s.binding_end_date,
-                s.binding_group_key,
-                s.notice_period_days,
-                s.billing_blocked,
-                s.billing_block_reason,
-                s.invoice_merge_key,
-                s.price_change_case_id,
-                s.renewal_case_id,
-                s.status,
-                s.notes,
-                s.cancelled_at,
-                s.cancellation_reason,
-                s.created_at,
-                s.updated_at
-            FROM sag_subscriptions s
-            LEFT JOIN sag_sager sg ON sg.id = s.sag_id
-            LEFT JOIN customers c ON c.id = s.customer_id
-            WHERE s.id = %s
-        """
-        subscription = execute_query_single(query, (subscription_id,))
-        if not subscription:
-            raise HTTPException(status_code=404, detail="Subscription not found")
-        
-        # Get line items
-        items = execute_query(
-            """
-            SELECT
-                i.id,
-                i.line_no,
-                i.product_id,
-                i.asset_id,
-                p.name AS product_name,
-                i.description,
-                i.quantity,
-                i.unit_price,
-                i.line_total,
-                i.period_from,
-                i.period_to,
-                i.requires_serial_number,
-                i.serial_number,
-                i.billing_blocked,
-                i.billing_block_reason
-            FROM sag_subscription_items i
-            LEFT JOIN products p ON p.id = i.product_id
-            WHERE i.subscription_id = %s
-            ORDER BY i.line_no ASC, i.id ASC
-            """,
-            (subscription_id,)
-        )
-        subscription["line_items"] = items or []
-        return subscription
+        return _load_subscription_with_context(subscription_id)
     except HTTPException:
         raise
     except Exception as e:
@@ -686,6 +700,45 @@ async def update_subscription(subscription_id: int, payload: Dict[str, Any]):
         
         # Extract line_items before processing other fields
         line_items = payload.pop("line_items", None)
+        normalized_line_items = None
+        if line_items is not None:
+            normalized_line_items = []
+            total_price = 0.0
+            first_description = None
+            for item in line_items:
+                description = (item.get("description", "") or "").strip()
+                quantity = float(item.get("quantity", 0) or 0)
+                unit_price = float(item.get("unit_price", 0) or 0)
+                if not description or quantity <= 0:
+                    continue
+                line_total = quantity * unit_price
+                total_price += line_total
+                if first_description is None:
+                    first_description = description
+                normalized_line_items.append({
+                    "description": description,
+                    "quantity": quantity,
+                    "unit_price": unit_price,
+                    "line_total": line_total,
+                    "product_id": item.get("product_id"),
+                    "asset_id": item.get("asset_id"),
+                    "period_from": item.get("period_from"),
+                    "period_to": item.get("period_to"),
+                    "price_type": item.get("price_type", "manual"),
+                    "custom_price_override": bool(item.get("custom_price_override")),
+                    "requires_serial_number": bool(item.get("requires_serial_number")),
+                    "serial_number": item.get("serial_number"),
+                    "billing_blocked": bool(item.get("billing_blocked")),
+                    "billing_block_reason": item.get("billing_block_reason"),
+                })
+            if not normalized_line_items:
+                raise HTTPException(status_code=400, detail="line_items must contain at least one valid line")
+            payload["price"] = total_price
+            payload["product_name"] = (
+                f"{first_description} (+{len(normalized_line_items) - 1})"
+                if len(normalized_line_items) > 1
+                else first_description
+            )
         
         # Build dynamic update query
         allowed_fields = {
@@ -729,7 +782,7 @@ async def update_subscription(subscription_id: int, payload: Dict[str, Any]):
                     result = cursor.fetchone()
                 
                 # Update line items if provided
-                if line_items is not None:
+                if normalized_line_items is not None:
                     # Delete existing line items
                     cursor.execute(
                         "DELETE FROM sag_subscription_items WHERE subscription_id = %s",
@@ -737,16 +790,7 @@ async def update_subscription(subscription_id: int, payload: Dict[str, Any]):
                     )
                     
                     # Insert new line items
-                    for idx, item in enumerate(line_items, start=1):
-                        description = item.get("description", "").strip()
-                        quantity = float(item.get("quantity", 0))
-                        unit_price = float(item.get("unit_price", 0))
-                        
-                        if not description or quantity <= 0:
-                            continue
-                        
-                        line_total = quantity * unit_price
-                        
+                    for idx, item in enumerate(normalized_line_items, start=1):
                         cursor.execute(
                             """
                             INSERT INTO sag_subscription_items (
@@ -759,8 +803,8 @@ async def update_subscription(subscription_id: int, payload: Dict[str, Any]):
                                 ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
                             """,
                             (
-                                subscription_id, idx, description,
-                                quantity, unit_price, line_total,
+                                subscription_id, idx, item["description"],
+                                item["quantity"], item["unit_price"], item["line_total"],
                                     item.get("product_id"),
                                     item.get("asset_id"),
                                     item.get("period_from"),
@@ -775,7 +819,7 @@ async def update_subscription(subscription_id: int, payload: Dict[str, Any]):
                         )
                 
                 conn.commit()
-                return result
+                return _load_subscription_with_context(subscription_id)
         finally:
             release_db_connection(conn)
     except HTTPException:
@@ -802,7 +846,7 @@ async def update_subscription_status(subscription_id: int, payload: Dict[str, An
         result = execute_query(query, (status, subscription_id))
         if not result:
             raise HTTPException(status_code=404, detail="Subscription not found")
-        return result[0]
+        return _load_subscription_with_context(subscription_id)
     except HTTPException:
         raise
     except Exception as e:
diff --git a/main.py b/main.py
index e388e3a..6b03e78 100644
--- a/main.py
+++ b/main.py
@@ -145,6 +145,8 @@ from app.modules.task_templates.backend import router as task_templates_api
 from app.modules.drift.backend import router as drift_api
 from app.modules.drift.frontend import views as drift_views
 from app.modules.drift.backend.router import run_uptime_kuma_sync
+from app.modules.internet_connections.backend import router as internet_connections_api
+from app.modules.internet_connections.frontend import views as internet_connections_views
 from app.bug_reports.backend import router as bug_reports_api
 
 # Configure logging
@@ -367,6 +369,8 @@ async def auth_middleware(request: Request, call_next):
         or any(path.startswith(prefix) for prefix in public_prefixes)
         or path.startswith("/static")
         or path.startswith("/docs")
+        or path.startswith("/api/v1/internet-connections")
+        or path.startswith("/economy/internet-connections")
     ):
         return await call_next(request)
 
@@ -479,6 +483,7 @@ app.include_router(bottom_bar_public_api.router, tags=["Bottom Bar Public"])
 app.include_router(rentals_api.router, prefix="/api/v1", tags=["Assets Rental Billing"])
 app.include_router(task_templates_api.router, prefix="/api/v1", tags=["Task Templates"])
 app.include_router(drift_api, prefix="/api/v1", tags=["Drift"])
+app.include_router(internet_connections_api.router, prefix="/api/v1", tags=["Internetforbindelser"])
 
 if settings.LINKS_MODULE_ENABLED:
     from app.modules.links.backend import router as links_api
@@ -516,6 +521,7 @@ app.include_router(fedex_views.router, tags=["Frontend"])
 app.include_router(anydesk_views.router, tags=["Frontend"])
 app.include_router(manual_views.router, tags=["Frontend"])
 app.include_router(drift_views.router, tags=["Frontend"])
+app.include_router(internet_connections_views.router, tags=["Frontend"])
 
 if settings.LINKS_MODULE_ENABLED:
     from app.modules.links.frontend import views as links_views
diff --git a/migrations/197_internet_connections_module.sql b/migrations/197_internet_connections_module.sql
new file mode 100644
index 0000000..26be8a5
--- /dev/null
+++ b/migrations/197_internet_connections_module.sql
@@ -0,0 +1,75 @@
+CREATE TABLE IF NOT EXISTS internet_connections_connections (
+    id SERIAL PRIMARY KEY,
+    parent_id INTEGER REFERENCES internet_connections_connections(id) ON DELETE SET NULL,
+    name VARCHAR(255) NOT NULL,
+    connection_type VARCHAR(50) NOT NULL DEFAULT 'fiber',
+    provider VARCHAR(255),
+    circuit_number VARCHAR(255),
+    customer_id INTEGER,
+    address VARCHAR(500),
+    speed_mbps INTEGER,
+    upload_mbps INTEGER,
+    download_mbps INTEGER,
+    technology VARCHAR(100),
+    status VARCHAR(50) NOT NULL DEFAULT 'active',
+    monthly_cost NUMERIC(12,2) DEFAULT 0,
+    sales_price NUMERIC(12,2) DEFAULT 0,
+    monitoring_url TEXT,
+    contract_start DATE,
+    contract_end DATE,
+    notes TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS internet_connections_ip_ranges (
+    id SERIAL PRIMARY KEY,
+    connection_id INTEGER REFERENCES internet_connections_connections(id) ON DELETE CASCADE,
+    name VARCHAR(255) NOT NULL,
+    cidr VARCHAR(32) NOT NULL,
+    description TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS internet_connections_ip_addresses (
+    id SERIAL PRIMARY KEY,
+    range_id INTEGER REFERENCES internet_connections_ip_ranges(id) ON DELETE CASCADE,
+    ip_address VARCHAR(64) NOT NULL,
+    status VARCHAR(50) NOT NULL DEFAULT 'available',
+    assigned_to VARCHAR(255),
+    assigned_type VARCHAR(50),
+    comment TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS internet_connections_history (
+    id SERIAL PRIMARY KEY,
+    connection_id INTEGER REFERENCES internet_connections_connections(id) ON DELETE CASCADE,
+    event_type VARCHAR(100) NOT NULL,
+    summary TEXT NOT NULL,
+    details JSONB DEFAULT '{}'::jsonb,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_by INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS internet_connections_pricing (
+    id SERIAL PRIMARY KEY,
+    connection_id INTEGER REFERENCES internet_connections_connections(id) ON DELETE CASCADE,
+    effective_from DATE NOT NULL,
+    purchase_price NUMERIC(12,2) DEFAULT 0,
+    sales_price NUMERIC(12,2) DEFAULT 0,
+    notes TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_by INTEGER
+);
+
+CREATE INDEX IF NOT EXISTS idx_internet_connections_parent_id ON internet_connections_connections(parent_id);
+CREATE INDEX IF NOT EXISTS idx_internet_connections_status ON internet_connections_connections(status);
+CREATE INDEX IF NOT EXISTS idx_internet_connections_ip_ranges_connection_id ON internet_connections_ip_ranges(connection_id);
+CREATE INDEX IF NOT EXISTS idx_internet_connections_ip_addresses_range_id ON internet_connections_ip_addresses(range_id);
+CREATE INDEX IF NOT EXISTS idx_internet_connections_history_connection_id ON internet_connections_history(connection_id);
diff --git a/migrations/198_globalconnect_ipam_enhancements.sql b/migrations/198_globalconnect_ipam_enhancements.sql
new file mode 100644
index 0000000..80a4da3
--- /dev/null
+++ b/migrations/198_globalconnect_ipam_enhancements.sql
@@ -0,0 +1,43 @@
+-- Migration 198: GlobalConnect extraction context + richer IPAM relations
+
+ALTER TABLE extraction_lines
+ADD COLUMN IF NOT EXISTS provider_reference VARCHAR(100),
+ADD COLUMN IF NOT EXISTS customer_reference VARCHAR(100),
+ADD COLUMN IF NOT EXISTS circuit_id VARCHAR(100),
+ADD COLUMN IF NOT EXISTS end_customer_name VARCHAR(255),
+ADD COLUMN IF NOT EXISTS period_start DATE,
+ADD COLUMN IF NOT EXISTS period_end DATE,
+ADD COLUMN IF NOT EXISTS service_address TEXT;
+
+CREATE INDEX IF NOT EXISTS idx_extraction_lines_provider_reference ON extraction_lines(provider_reference);
+CREATE INDEX IF NOT EXISTS idx_extraction_lines_circuit_id ON extraction_lines(circuit_id);
+CREATE INDEX IF NOT EXISTS idx_extraction_lines_end_customer_name ON extraction_lines(end_customer_name);
+
+COMMENT ON COLUMN extraction_lines.provider_reference IS 'Provider reference from invoice context (e.g. DSL-EB722388, NKA020902)';
+COMMENT ON COLUMN extraction_lines.customer_reference IS 'Customer account/reference from supplier invoice';
+COMMENT ON COLUMN extraction_lines.circuit_id IS 'Circuit or service identifier for the billed line';
+COMMENT ON COLUMN extraction_lines.end_customer_name IS 'Named end customer from invoice context';
+COMMENT ON COLUMN extraction_lines.period_start IS 'Billing period start date for the extracted line';
+COMMENT ON COLUMN extraction_lines.period_end IS 'Billing period end date for the extracted line';
+COMMENT ON COLUMN extraction_lines.service_address IS 'Full service address captured from invoice context';
+
+ALTER TABLE internet_connections_ip_ranges
+ADD COLUMN IF NOT EXISTS provider_reference VARCHAR(100),
+ADD COLUMN IF NOT EXISTS contract_number VARCHAR(100),
+ADD COLUMN IF NOT EXISTS customer_id INTEGER REFERENCES customers(id) ON DELETE SET NULL,
+ADD COLUMN IF NOT EXISTS service_address VARCHAR(500),
+ADD COLUMN IF NOT EXISTS monthly_cost NUMERIC(12,2) DEFAULT 0,
+ADD COLUMN IF NOT EXISTS sales_price NUMERIC(12,2) DEFAULT 0;
+
+CREATE INDEX IF NOT EXISTS idx_internet_connections_ip_ranges_customer_id
+ON internet_connections_ip_ranges(customer_id);
+
+ALTER TABLE internet_connections_ip_addresses
+ADD COLUMN IF NOT EXISTS assigned_customer_id INTEGER REFERENCES customers(id) ON DELETE SET NULL,
+ADD COLUMN IF NOT EXISTS assigned_connection_id INTEGER REFERENCES internet_connections_connections(id) ON DELETE SET NULL;
+
+CREATE INDEX IF NOT EXISTS idx_internet_connections_ip_addresses_assigned_customer_id
+ON internet_connections_ip_addresses(assigned_customer_id);
+
+CREATE INDEX IF NOT EXISTS idx_internet_connections_ip_addresses_assigned_connection_id
+ON internet_connections_ip_addresses(assigned_connection_id);
diff --git a/migrations/199_internet_connection_value_model.sql b/migrations/199_internet_connection_value_model.sql
new file mode 100644
index 0000000..8eb6673
--- /dev/null
+++ b/migrations/199_internet_connection_value_model.sql
@@ -0,0 +1,52 @@
+ALTER TABLE internet_connections_connections
+ADD COLUMN IF NOT EXISTS allocation_model VARCHAR(20) NOT NULL DEFAULT 'dedicated',
+ADD COLUMN IF NOT EXISTS value_type VARCHAR(30) NOT NULL DEFAULT 'other',
+ADD COLUMN IF NOT EXISTS value_label VARCHAR(120),
+ADD COLUMN IF NOT EXISTS subscription_id INTEGER REFERENCES sag_subscriptions(id) ON DELETE SET NULL;
+
+UPDATE internet_connections_connections
+SET allocation_model = 'shared',
+    value_type = 'bmc_networks',
+    value_label = NULL,
+    updated_at = CURRENT_TIMESTAMP
+WHERE deleted_at IS NULL
+  AND customer_id IN (
+      SELECT id
+      FROM customers
+      WHERE is_active = true
+        AND LOWER(name) = 'bmc networks'
+  );
+
+UPDATE internet_connections_connections
+SET allocation_model = COALESCE(NULLIF(allocation_model, ''), 'dedicated'),
+    value_type = CASE
+        WHEN value_type IN ('subscription', 'bmc_networks', 'delefiber', 'other') THEN value_type
+        ELSE 'other'
+    END,
+    value_label = CASE
+        WHEN value_type = 'other' AND COALESCE(NULLIF(TRIM(value_label), ''), '') = '' THEN 'Mangler klassifikation'
+        WHEN value_type IN ('bmc_networks', 'delefiber', 'subscription') THEN NULL
+        ELSE value_label
+    END,
+    updated_at = CURRENT_TIMESTAMP
+WHERE deleted_at IS NULL
+  AND NOT (
+      allocation_model = 'shared'
+      AND value_type = 'bmc_networks'
+      AND customer_id IN (
+          SELECT id
+          FROM customers
+          WHERE is_active = true
+            AND LOWER(name) = 'bmc networks'
+      )
+  );
+
+CREATE INDEX IF NOT EXISTS idx_internet_connections_allocation_model
+ON internet_connections_connections(allocation_model);
+
+CREATE INDEX IF NOT EXISTS idx_internet_connections_value_type
+ON internet_connections_connections(value_type);
+
+CREATE INDEX IF NOT EXISTS idx_internet_connections_subscription_id
+ON internet_connections_connections(subscription_id)
+WHERE subscription_id IS NOT NULL;
diff --git a/migrations/200_internet_ip_unique.sql b/migrations/200_internet_ip_unique.sql
new file mode 100644
index 0000000..a66ec97
--- /dev/null
+++ b/migrations/200_internet_ip_unique.sql
@@ -0,0 +1,31 @@
+WITH ranked AS (
+    SELECT
+        id,
+        ip_address,
+        ROW_NUMBER() OVER (
+            PARTITION BY ip_address
+            ORDER BY
+                CASE WHEN deleted_at IS NULL THEN 0 ELSE 1 END,
+                id
+        ) AS row_no
+    FROM internet_connections_ip_addresses
+),
+duplicates AS (
+    SELECT id
+    FROM ranked
+    WHERE row_no > 1
+)
+UPDATE internet_connections_ip_addresses ipa
+SET deleted_at = CURRENT_TIMESTAMP,
+    updated_at = CURRENT_TIMESTAMP,
+    comment = CONCAT(
+        COALESCE(ipa.comment, ''),
+        CASE WHEN COALESCE(ipa.comment, '') = '' THEN '' ELSE E'\n' END,
+        'Automatisk deaktiveret som dublet-IP før unikregel.'
+    )
+WHERE ipa.id IN (SELECT id FROM duplicates)
+  AND ipa.deleted_at IS NULL;
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_internet_connections_ip_addresses_ip_address_active
+ON internet_connections_ip_addresses (ip_address)
+WHERE deleted_at IS NULL;
diff --git a/migrations/201_cleanup_globalconnect_connections_without_address.sql b/migrations/201_cleanup_globalconnect_connections_without_address.sql
new file mode 100644
index 0000000..eab0620
--- /dev/null
+++ b/migrations/201_cleanup_globalconnect_connections_without_address.sql
@@ -0,0 +1,53 @@
+WITH bad_connections AS (
+    SELECT id
+    FROM internet_connections_connections
+    WHERE deleted_at IS NULL
+      AND provider ILIKE 'GlobalConnect%'
+      AND (address IS NULL OR BTRIM(address) = '')
+)
+UPDATE internet_connections_ip_addresses
+SET deleted_at = CURRENT_TIMESTAMP,
+    updated_at = CURRENT_TIMESTAMP,
+    comment = CONCAT(
+        COALESCE(comment, ''),
+        CASE WHEN COALESCE(comment, '') = '' THEN '' ELSE E'\n' END,
+        'Skjult sammen med fejlimporteret forbindelse uden adresse.'
+    )
+WHERE deleted_at IS NULL
+  AND range_id IN (
+      SELECT id
+      FROM internet_connections_ip_ranges
+      WHERE connection_id IN (SELECT id FROM bad_connections)
+        AND deleted_at IS NULL
+  );
+
+WITH bad_connections AS (
+    SELECT id
+    FROM internet_connections_connections
+    WHERE deleted_at IS NULL
+      AND provider ILIKE 'GlobalConnect%'
+      AND (address IS NULL OR BTRIM(address) = '')
+)
+UPDATE internet_connections_ip_ranges
+SET deleted_at = CURRENT_TIMESTAMP,
+    updated_at = CURRENT_TIMESTAMP,
+    description = CONCAT(
+        COALESCE(description, ''),
+        CASE WHEN COALESCE(description, '') = '' THEN '' ELSE E'\n' END,
+        'Skjult sammen med fejlimporteret forbindelse uden adresse.'
+    )
+WHERE deleted_at IS NULL
+  AND connection_id IN (SELECT id FROM bad_connections);
+
+UPDATE internet_connections_connections
+SET deleted_at = CURRENT_TIMESTAMP,
+    updated_at = CURRENT_TIMESTAMP,
+    notes = CONCAT(
+        COALESCE(notes, ''),
+        CASE WHEN COALESCE(notes, '') = '' THEN '' ELSE E'\n' END,
+        'Automatisk skjult fordi forbindelsen manglede adresse efter import.'
+    ),
+    status = 'pending'
+WHERE deleted_at IS NULL
+  AND provider ILIKE 'GlobalConnect%'
+  AND (address IS NULL OR BTRIM(address) = '');
diff --git a/migrations/202_backfill_connection_addresses_from_extraction.sql b/migrations/202_backfill_connection_addresses_from_extraction.sql
new file mode 100644
index 0000000..860853c
--- /dev/null
+++ b/migrations/202_backfill_connection_addresses_from_extraction.sql
@@ -0,0 +1,27 @@
+WITH normalized_extraction_addresses AS (
+    SELECT
+        regexp_replace(UPPER(COALESCE(provider_reference, circuit_id, '')), '[^A-Z0-9]', '', 'g') AS ref_norm,
+        NULLIF(BTRIM(service_address), '') AS service_address
+    FROM extraction_lines
+    WHERE NULLIF(BTRIM(service_address), '') IS NOT NULL
+),
+unique_addresses AS (
+    SELECT
+        ref_norm,
+        MIN(service_address) AS service_address
+    FROM normalized_extraction_addresses
+    GROUP BY ref_norm
+    HAVING COUNT(DISTINCT service_address) = 1
+)
+UPDATE internet_connections_connections c
+SET address = u.service_address,
+    updated_at = CURRENT_TIMESTAMP,
+    notes = CONCAT(
+        COALESCE(c.notes, ''),
+        CASE WHEN COALESCE(c.notes, '') = '' THEN '' ELSE E'\n' END,
+        'Adresse backfill fra extraction-data.'
+    )
+FROM unique_addresses u
+WHERE c.deleted_at IS NULL
+  AND (c.address IS NULL OR BTRIM(c.address) = '')
+  AND regexp_replace(UPPER(COALESCE(c.circuit_number, '')), '[^A-Z0-9]', '', 'g') = u.ref_norm;
diff --git a/migrations/203_seed_bmc_network_subscription_products.sql b/migrations/203_seed_bmc_network_subscription_products.sql
new file mode 100644
index 0000000..57de1b8
--- /dev/null
+++ b/migrations/203_seed_bmc_network_subscription_products.sql
@@ -0,0 +1,159 @@
+WITH seed_products AS (
+    SELECT *
+    FROM (
+        VALUES
+            (
+                'BMCnet 100/100',
+                'Delt BMC internetforbindelse 100/100 Mbit',
+                'service',
+                'monthly',
+                0.00::DECIMAL(10,2),
+                jsonb_build_object(
+                    'network',
+                    jsonb_build_object(
+                        'kind', 'internet_access',
+                        'connection_type', 'fiber',
+                        'speed_mbps', 100,
+                        'download_mbps', 100,
+                        'upload_mbps', 100
+                    )
+                )
+            ),
+            (
+                'BMCnet 250/250',
+                'Delt BMC internetforbindelse 250/250 Mbit',
+                'service',
+                'monthly',
+                0.00::DECIMAL(10,2),
+                jsonb_build_object(
+                    'network',
+                    jsonb_build_object(
+                        'kind', 'internet_access',
+                        'connection_type', 'fiber',
+                        'speed_mbps', 250,
+                        'download_mbps', 250,
+                        'upload_mbps', 250
+                    )
+                )
+            ),
+            (
+                'BMCnet 500/500',
+                'Delt BMC internetforbindelse 500/500 Mbit',
+                'service',
+                'monthly',
+                0.00::DECIMAL(10,2),
+                jsonb_build_object(
+                    'network',
+                    jsonb_build_object(
+                        'kind', 'internet_access',
+                        'connection_type', 'fiber',
+                        'speed_mbps', 500,
+                        'download_mbps', 500,
+                        'upload_mbps', 500
+                    )
+                )
+            ),
+            (
+                'BMCnet 1000/1000',
+                'Delt BMC internetforbindelse 1000/1000 Mbit',
+                'service',
+                'monthly',
+                0.00::DECIMAL(10,2),
+                jsonb_build_object(
+                    'network',
+                    jsonb_build_object(
+                        'kind', 'internet_access',
+                        'connection_type', 'fiber',
+                        'speed_mbps', 1000,
+                        'download_mbps', 1000,
+                        'upload_mbps', 1000
+                    )
+                )
+            ),
+            (
+                '/30 IP',
+                'Offentlig IPv4-allokering /30',
+                'service',
+                'monthly',
+                0.00::DECIMAL(10,2),
+                jsonb_build_object(
+                    'network',
+                    jsonb_build_object(
+                        'kind', 'ip_allocation',
+                        'ip_prefix_length', 30
+                    )
+                )
+            ),
+            (
+                '/29 IP',
+                'Offentlig IPv4-allokering /29',
+                'service',
+                'monthly',
+                0.00::DECIMAL(10,2),
+                jsonb_build_object(
+                    'network',
+                    jsonb_build_object(
+                        'kind', 'ip_allocation',
+                        'ip_prefix_length', 29
+                    )
+                )
+            ),
+            (
+                '/28 IP',
+                'Offentlig IPv4-allokering /28',
+                'service',
+                'monthly',
+                0.00::DECIMAL(10,2),
+                jsonb_build_object(
+                    'network',
+                    jsonb_build_object(
+                        'kind', 'ip_allocation',
+                        'ip_prefix_length', 28
+                    )
+                )
+            )
+    ) AS t(name, short_description, type, billing_period, sales_price, attributes_json)
+),
+updated AS (
+    UPDATE products p
+    SET short_description = s.short_description,
+        type = COALESCE(NULLIF(p.type, ''), s.type),
+        billing_period = COALESCE(NULLIF(p.billing_period, ''), s.billing_period),
+        sales_price = COALESCE(p.sales_price, s.sales_price),
+        status = 'active',
+        billable = true,
+        attributes_json = COALESCE(p.attributes_json, '{}'::jsonb) || s.attributes_json,
+        updated_at = CURRENT_TIMESTAMP
+    FROM seed_products s
+    WHERE p.deleted_at IS NULL
+      AND LOWER(p.name) = LOWER(s.name)
+    RETURNING p.id, p.name
+)
+INSERT INTO products (
+    name,
+    short_description,
+    type,
+    status,
+    sales_price,
+    vat_rate,
+    billing_period,
+    billable,
+    attributes_json
+)
+SELECT
+    s.name,
+    s.short_description,
+    s.type,
+    'active',
+    s.sales_price,
+    25.00,
+    s.billing_period,
+    true,
+    s.attributes_json
+FROM seed_products s
+WHERE NOT EXISTS (
+    SELECT 1
+    FROM products p
+    WHERE p.deleted_at IS NULL
+      AND LOWER(p.name) = LOWER(s.name)
+);
diff --git a/migrations/204_backfill_shared_bmc_heads.sql b/migrations/204_backfill_shared_bmc_heads.sql
new file mode 100644
index 0000000..66eca57
--- /dev/null
+++ b/migrations/204_backfill_shared_bmc_heads.sql
@@ -0,0 +1,26 @@
+WITH bmc_owner AS (
+    SELECT MIN(id) AS id
+    FROM customers
+    WHERE lower(name) = 'bmc networks'
+      AND is_active = true
+),
+candidate_connections AS (
+    SELECT DISTINCT ic.id
+    FROM internet_connections_connections ic
+    JOIN internet_connections_ip_ranges ir
+      ON ir.connection_id = ic.id
+     AND ir.deleted_at IS NULL
+    WHERE ic.deleted_at IS NULL
+      AND ic.parent_id IS NULL
+      AND ic.subscription_id IS NULL
+      AND ic.provider ILIKE 'GlobalConnect%'
+      AND ir.customer_id IS NULL
+      AND COALESCE(ic.address, '') <> ''
+)
+UPDATE internet_connections_connections ic
+SET customer_id = COALESCE((SELECT id FROM bmc_owner), ic.customer_id),
+    allocation_model = 'shared',
+    value_type = 'bmc_networks',
+    value_label = NULL,
+    updated_at = CURRENT_TIMESTAMP
+WHERE ic.id IN (SELECT id FROM candidate_connections);
diff --git a/migrations/205_realign_mismatched_ip_ranges.sql b/migrations/205_realign_mismatched_ip_ranges.sql
new file mode 100644
index 0000000..db66f5d
--- /dev/null
+++ b/migrations/205_realign_mismatched_ip_ranges.sql
@@ -0,0 +1,35 @@
+WITH mismatched AS (
+    SELECT
+        ir.id AS range_id,
+        ir.service_address
+    FROM internet_connections_ip_ranges ir
+    JOIN internet_connections_connections current_conn
+      ON current_conn.id = ir.connection_id
+    WHERE ir.deleted_at IS NULL
+      AND current_conn.deleted_at IS NULL
+      AND current_conn.allocation_model <> 'shared'
+      AND ir.service_address IS NOT NULL
+      AND regexp_replace(upper(coalesce(ir.service_address, '')), '[^A-Z0-9]', '', 'g')
+          <> regexp_replace(upper(coalesce(current_conn.address, '')), '[^A-Z0-9]', '', 'g')
+),
+candidate_matches AS (
+    SELECT
+        m.range_id,
+        candidate.id AS target_connection_id,
+        COUNT(*) OVER (PARTITION BY m.range_id) AS candidate_count
+    FROM mismatched m
+    JOIN internet_connections_connections candidate
+      ON candidate.deleted_at IS NULL
+     AND regexp_replace(upper(coalesce(candidate.address, '')), '[^A-Z0-9]', '', 'g')
+         = regexp_replace(upper(coalesce(m.service_address, '')), '[^A-Z0-9]', '', 'g')
+),
+unique_targets AS (
+    SELECT range_id, target_connection_id
+    FROM candidate_matches
+    WHERE candidate_count = 1
+)
+UPDATE internet_connections_ip_ranges ir
+SET connection_id = ut.target_connection_id,
+    updated_at = CURRENT_TIMESTAMP
+FROM unique_targets ut
+WHERE ir.id = ut.range_id;
diff --git a/migrations/206_normalize_bmc_networks_heads.sql b/migrations/206_normalize_bmc_networks_heads.sql
new file mode 100644
index 0000000..186cfd3
--- /dev/null
+++ b/migrations/206_normalize_bmc_networks_heads.sql
@@ -0,0 +1,15 @@
+WITH bmc_owner AS (
+    SELECT MIN(id) AS id
+    FROM customers
+    WHERE lower(name) = 'bmc networks'
+      AND is_active = true
+)
+UPDATE internet_connections_connections ic
+SET customer_id = COALESCE((SELECT id FROM bmc_owner), ic.customer_id),
+    allocation_model = 'shared',
+    value_type = 'bmc_networks',
+    value_label = NULL,
+    updated_at = CURRENT_TIMESTAMP
+WHERE ic.deleted_at IS NULL
+  AND ic.parent_id IS NULL
+  AND ic.value_type = 'bmc_networks';
diff --git a/migrations/207_fix_nka020900_ip_range_mapping.sql b/migrations/207_fix_nka020900_ip_range_mapping.sql
new file mode 100644
index 0000000..cb53fed
--- /dev/null
+++ b/migrations/207_fix_nka020900_ip_range_mapping.sql
@@ -0,0 +1,8 @@
+UPDATE internet_connections_ip_ranges
+SET service_address = 'Rydagervej 27, 2620 Albertslund',
+    customer_id = NULL,
+    monthly_cost = 64.00,
+    updated_at = CURRENT_TIMESTAMP
+WHERE deleted_at IS NULL
+  AND provider_reference = 'NKA-020900'
+  AND cidr = '87.116.1.200/29';
diff --git a/migrations/208_seed_bmcnet_static_wan_ip.sql b/migrations/208_seed_bmcnet_static_wan_ip.sql
new file mode 100644
index 0000000..9c4e7b7
--- /dev/null
+++ b/migrations/208_seed_bmcnet_static_wan_ip.sql
@@ -0,0 +1,58 @@
+WITH seed_product AS (
+    SELECT
+        'BMCnet Statisk WAN IP'::TEXT AS name,
+        'Statisk offentlig WAN IPv4-adresse'::TEXT AS short_description,
+        'service'::TEXT AS type,
+        'monthly'::TEXT AS billing_period,
+        0.00::DECIMAL(10,2) AS sales_price,
+        jsonb_build_object(
+            'network',
+            jsonb_build_object(
+                'kind', 'ip_allocation',
+                'ip_prefix_length', 32
+            )
+        ) AS attributes_json
+),
+updated AS (
+    UPDATE products p
+    SET short_description = s.short_description,
+        type = COALESCE(NULLIF(p.type, ''), s.type),
+        billing_period = COALESCE(NULLIF(p.billing_period, ''), s.billing_period),
+        sales_price = COALESCE(p.sales_price, s.sales_price),
+        status = 'active',
+        billable = true,
+        attributes_json = COALESCE(p.attributes_json, '{}'::jsonb) || s.attributes_json,
+        updated_at = CURRENT_TIMESTAMP
+    FROM seed_product s
+    WHERE p.deleted_at IS NULL
+      AND LOWER(p.name) = LOWER(s.name)
+    RETURNING p.id
+)
+INSERT INTO products (
+    name,
+    short_description,
+    type,
+    status,
+    sales_price,
+    vat_rate,
+    billing_period,
+    billable,
+    attributes_json
+)
+SELECT
+    s.name,
+    s.short_description,
+    s.type,
+    'active',
+    s.sales_price,
+    25.00,
+    s.billing_period,
+    true,
+    s.attributes_json
+FROM seed_product s
+WHERE NOT EXISTS (
+    SELECT 1
+    FROM products p
+    WHERE p.deleted_at IS NULL
+      AND LOWER(p.name) = LOWER(s.name)
+);
diff --git a/migrations/209_internet_customer_documents.sql b/migrations/209_internet_customer_documents.sql
new file mode 100644
index 0000000..8140d55
--- /dev/null
+++ b/migrations/209_internet_customer_documents.sql
@@ -0,0 +1,68 @@
+CREATE TABLE IF NOT EXISTS internet_connections_customer_documents (
+    id SERIAL PRIMARY KEY,
+    customer_id INTEGER REFERENCES customers(id) ON DELETE SET NULL,
+    connection_id INTEGER REFERENCES internet_connections_connections(id) ON DELETE SET NULL,
+    filename VARCHAR(500) NOT NULL,
+    original_filename VARCHAR(500) NOT NULL,
+    file_path VARCHAR(1000) NOT NULL,
+    file_size INTEGER,
+    mime_type VARCHAR(120),
+    checksum VARCHAR(64) NOT NULL,
+    extracted_text TEXT,
+    notes TEXT,
+    uploaded_by INTEGER,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_internet_customer_documents_customer
+ON internet_connections_customer_documents(customer_id)
+WHERE deleted_at IS NULL;
+
+CREATE INDEX IF NOT EXISTS idx_internet_customer_documents_connection
+ON internet_connections_customer_documents(connection_id)
+WHERE deleted_at IS NULL;
+
+CREATE INDEX IF NOT EXISTS idx_internet_customer_documents_checksum
+ON internet_connections_customer_documents(checksum);
+
+CREATE INDEX IF NOT EXISTS idx_internet_customer_documents_created_at
+ON internet_connections_customer_documents(created_at DESC)
+WHERE deleted_at IS NULL;
+
+CREATE OR REPLACE FUNCTION update_internet_customer_documents_updated_at()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS trigger_update_internet_customer_documents_updated_at
+ON internet_connections_customer_documents;
+
+CREATE TRIGGER trigger_update_internet_customer_documents_updated_at
+    BEFORE UPDATE ON internet_connections_customer_documents
+    FOR EACH ROW
+    EXECUTE FUNCTION update_internet_customer_documents_updated_at();
+
+COMMENT ON TABLE internet_connections_customer_documents IS 'Kundeoplaeste tekstfiler til internetforbindelser og historisk research';
+COMMENT ON COLUMN internet_connections_customer_documents.extracted_text IS 'Udtrukket/forsynlig tekst som wizard v2 og AI kan soege i';
+
+CREATE TABLE IF NOT EXISTS internet_connections_customer_document_segments (
+    id SERIAL PRIMARY KEY,
+    document_id INTEGER NOT NULL REFERENCES internet_connections_customer_documents(id) ON DELETE CASCADE,
+    block_index INTEGER NOT NULL,
+    block_title VARCHAR(255),
+    content TEXT NOT NULL,
+    ip_addresses JSONB NOT NULL DEFAULT '[]'::jsonb,
+    cidr_blocks JSONB NOT NULL DEFAULT '[]'::jsonb,
+    references_json JSONB NOT NULL DEFAULT '[]'::jsonb,
+    socket_numbers JSONB NOT NULL DEFAULT '[]'::jsonb,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(document_id, block_index)
+);
+
+CREATE INDEX IF NOT EXISTS idx_internet_customer_document_segments_document
+ON internet_connections_customer_document_segments(document_id);
diff --git a/scripts/reprocess_supplier_invoice_files.py b/scripts/reprocess_supplier_invoice_files.py
new file mode 100644
index 0000000..e0fbc9b
--- /dev/null
+++ b/scripts/reprocess_supplier_invoice_files.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""Reprocess stored supplier-invoice files through the app code."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+
+from app.billing.backend.supplier_invoices import reprocess_uploaded_file
+from app.core.database import init_db
+
+
+async def _run(file_ids: list[int]) -> list[dict]:
+    results = []
+    for file_id in file_ids:
+        result = await reprocess_uploaded_file(file_id)
+        results.append({"file_id": file_id, "result": result})
+    return results
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("file_ids", nargs="+", type=int)
+    args = parser.parse_args()
+
+    init_db()
+    payload = asyncio.run(_run(args.file_ids))
+    print(json.dumps(payload, ensure_ascii=False, indent=2, default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/reset_and_rebuild_internet_connections.py b/scripts/reset_and_rebuild_internet_connections.py
new file mode 100644
index 0000000..79dc2c7
--- /dev/null
+++ b/scripts/reset_and_rebuild_internet_connections.py
@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""Reset internet connection data and rebuild from latest GlobalConnect extractions."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections import defaultdict
+
+from app.billing.backend.supplier_invoices import _sync_globalconnect_extraction_to_internet
+from app.core.database import execute_query, execute_query_single, execute_update, init_db
+
+
+def latest_globalconnect_extractions() -> list[dict]:
+    rows = execute_query(
+        """
+        SELECT DISTINCT ON (e.file_id)
+            e.extraction_id,
+            e.file_id,
+            e.vendor_name,
+            e.document_id,
+            e.document_date,
+            e.created_at,
+            i.filename
+        FROM extractions e
+        JOIN incoming_files i ON i.file_id = e.file_id
+        WHERE LOWER(COALESCE(e.vendor_name, '')) LIKE '%%globalconnect%%'
+        ORDER BY e.file_id, e.created_at DESC, e.extraction_id DESC
+        """
+    ) or []
+    return [dict(row) for row in rows]
+
+
+def reset_all_internet_data() -> dict:
+    summary: dict[str, int] = {}
+    counts = execute_query_single(
+        """
+        SELECT
+            (SELECT COUNT(*) FROM internet_connections_connections WHERE deleted_at IS NULL) AS connections,
+            (SELECT COUNT(*) FROM internet_connections_ip_ranges WHERE deleted_at IS NULL) AS ip_ranges,
+            (SELECT COUNT(*) FROM internet_connections_ip_addresses WHERE deleted_at IS NULL) AS ip_addresses,
+            (SELECT COUNT(*) FROM internet_connections_pricing) AS pricing,
+            (SELECT COUNT(*) FROM internet_connections_history) AS history
+        """
+    ) or {}
+    summary["before_connections"] = int(counts.get("connections") or 0)
+    summary["before_ip_ranges"] = int(counts.get("ip_ranges") or 0)
+    summary["before_ip_addresses"] = int(counts.get("ip_addresses") or 0)
+    summary["before_pricing"] = int(counts.get("pricing") or 0)
+    summary["before_history"] = int(counts.get("history") or 0)
+
+    summary["deleted_ip_addresses"] = execute_update(
+        """
+        UPDATE internet_connections_ip_addresses
+        SET deleted_at = CURRENT_TIMESTAMP,
+            updated_at = CURRENT_TIMESTAMP,
+            comment = CONCAT(
+                COALESCE(comment, ''),
+                CASE WHEN COALESCE(comment, '') = '' THEN '' ELSE E'\n' END,
+                'Nulstillet før ren genimport af internetforbindelser.'
+            )
+        WHERE deleted_at IS NULL
+        """
+    )
+    summary["deleted_ip_ranges"] = execute_update(
+        """
+        UPDATE internet_connections_ip_ranges
+        SET deleted_at = CURRENT_TIMESTAMP,
+            updated_at = CURRENT_TIMESTAMP,
+            description = CONCAT(
+                COALESCE(description, ''),
+                CASE WHEN COALESCE(description, '') = '' THEN '' ELSE E'\n' END,
+                'Nulstillet før ren genimport af internetforbindelser.'
+            )
+        WHERE deleted_at IS NULL
+        """
+    )
+    summary["deleted_connections"] = execute_update(
+        """
+        UPDATE internet_connections_connections
+        SET deleted_at = CURRENT_TIMESTAMP,
+            updated_at = CURRENT_TIMESTAMP,
+            status = 'inactive',
+            notes = CONCAT(
+                COALESCE(notes, ''),
+                CASE WHEN COALESCE(notes, '') = '' THEN '' ELSE E'\n' END,
+                'Nulstillet før ren genimport af internetforbindelser.'
+            )
+        WHERE deleted_at IS NULL
+        """
+    )
+    summary["deleted_pricing"] = execute_update("DELETE FROM internet_connections_pricing")
+    summary["deleted_history"] = execute_update("DELETE FROM internet_connections_history")
+    return summary
+
+
+def rebuild_from_globalconnect() -> dict:
+    extractions = latest_globalconnect_extractions()
+    results = []
+    totals = defaultdict(int)
+
+    for extraction_stub in extractions:
+        extraction = execute_query_single(
+            """
+            SELECT *
+            FROM extractions
+            WHERE extraction_id = %s
+            """,
+            (extraction_stub["extraction_id"],),
+        )
+        if not extraction:
+            continue
+        result = _sync_globalconnect_extraction_to_internet(dict(extraction))
+        result_summary = {
+            "file_id": extraction_stub["file_id"],
+            "extraction_id": extraction_stub["extraction_id"],
+            "filename": extraction_stub["filename"],
+            "document_id": extraction_stub["document_id"],
+            "connections_synced": int(result.get("connections_synced") or 0),
+            "connections_created": int(result.get("connections_created") or 0),
+            "connections_updated": int(result.get("connections_updated") or 0),
+            "ip_ranges_synced": int(result.get("ip_ranges_synced") or 0),
+            "skipped_connection_lines": int(result.get("skipped_connection_lines") or 0),
+            "skipped_ip_range_lines": int(result.get("skipped_orphan_ip_ranges") or 0),
+            "verification": result.get("verification") or {},
+        }
+        results.append(result_summary)
+        totals["files_processed"] += 1
+        totals["connections_synced"] += result_summary["connections_synced"]
+        totals["connections_created"] += result_summary["connections_created"]
+        totals["connections_updated"] += result_summary["connections_updated"]
+        totals["ip_ranges_synced"] += result_summary["ip_ranges_synced"]
+        totals["skipped_connection_lines"] += result_summary["skipped_connection_lines"]
+        totals["skipped_ip_range_lines"] += result_summary["skipped_ip_range_lines"]
+
+    counts = execute_query_single(
+        """
+        SELECT
+            (SELECT COUNT(*) FROM internet_connections_connections WHERE deleted_at IS NULL) AS active_connections,
+            (SELECT COUNT(*) FROM internet_connections_connections WHERE deleted_at IS NULL AND (address IS NULL OR BTRIM(address) = '')) AS missing_address_connections,
+            (SELECT COUNT(*) FROM internet_connections_ip_ranges WHERE deleted_at IS NULL) AS active_ip_ranges,
+            (SELECT COUNT(*) FROM internet_connections_ip_addresses WHERE deleted_at IS NULL) AS active_ip_addresses
+        """
+    ) or {}
+    return {
+        "totals": dict(totals),
+        "results": results,
+        "post_counts": {
+            "active_connections": int(counts.get("active_connections") or 0),
+            "missing_address_connections": int(counts.get("missing_address_connections") or 0),
+            "active_ip_ranges": int(counts.get("active_ip_ranges") or 0),
+            "active_ip_addresses": int(counts.get("active_ip_addresses") or 0),
+        },
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--skip-rebuild", action="store_true", help="Only reset internet data")
+    args = parser.parse_args()
+
+    init_db()
+    payload = {
+        "reset": reset_all_internet_data(),
+        "rebuild": None if args.skip_rebuild else rebuild_from_globalconnect(),
+    }
+    print(json.dumps(payload, ensure_ascii=False, indent=2, default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/static/js/sms.js b/static/js/sms.js
index 8b0d2a2..68bbe5f 100644
--- a/static/js/sms.js
+++ b/static/js/sms.js
@@ -3,11 +3,23 @@ let smsModalInstance = null;
 function normalizeSmsNumber(number) {
     const raw = String(number || '').trim();
     if (!raw) return '';
-    let cleaned = raw.replace(/[^\d+]/g, '');
-    if (cleaned.startsWith('+')) cleaned = cleaned.slice(1);
-    if (cleaned.startsWith('00')) cleaned = cleaned.slice(2);
-    if (/^\d{8}$/.test(cleaned)) cleaned = `45${cleaned}`;
-    return cleaned;
+    const cleaned = raw.replace(/[^\d+]/g, '');
+    if (!cleaned) return '';
+
+    if (cleaned.startsWith('+')) {
+        const digits = cleaned.slice(1).replace(/\D+/g, '');
+        return digits.length >= 9 ? digits : '';
+    }
+
+    if (cleaned.startsWith('00')) {
+        const digits = cleaned.slice(2).replace(/\D+/g, '');
+        return digits.length >= 9 ? digits : '';
+    }
+
+    const digits = cleaned.replace(/\D+/g, '');
+    if (/^\d{8}$/.test(digits)) return `45${digits}`;
+    if (digits.length >= 9) return digits;
+    return '';
 }
 
 async function sendSms(number, message, sender = null, contactId = null) {
diff --git a/tests/test_globalconnect_internet_sync.py b/tests/test_globalconnect_internet_sync.py
new file mode 100644
index 0000000..264ed85
--- /dev/null
+++ b/tests/test_globalconnect_internet_sync.py
@@ -0,0 +1,797 @@
+import sys
+from decimal import Decimal
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from app.billing.backend import supplier_invoices as supplier_module
+
+
+def test_sync_globalconnect_extraction_creates_connections_and_ip_ranges(monkeypatch):
+    created_connections = []
+    created_ranges = []
+    ensured_ranges = []
+
+    extraction = {
+        "extraction_id": 176,
+        "vendor_name": "GlobalConnect A/S",
+        "document_id": "3018657",
+        "document_date": "2026-01-01",
+        "llm_response_json": {"template": "dk.globalconnect"},
+    }
+    lines = [
+        {
+            "description": "100 Mbps fiberforbindelse",
+            "provider_reference": "NKA008214",
+            "circuit_id": "NKA008214",
+            "line_total": 2850.0,
+            "unit_price": 950.0,
+            "quantity": 3,
+            "end_customer_name": "Malerfirmaet Gert Jensen ApS",
+            "service_address": "Metalbuen 26, 2750 Ballerup",
+        },
+        {
+            "description": "IPv4 IP-adresser",
+            "provider_reference": "NKA008214",
+            "circuit_id": "NKA008214",
+            "ip_address": "152.115.84.232/29",
+            "line_total": 192.0,
+            "unit_price": 64.0,
+            "quantity": 3,
+            "end_customer_name": "Malerfirmaet Gert Jensen ApS",
+            "service_address": "Metalbuen 26, 2750 Ballerup",
+        },
+    ]
+
+    def fake_load_lines(_):
+        return lines
+
+    def fake_load_customers():
+        return [{"id": 322, "name": "Malerfirmaet Gert Jensen ApS", "address": "Metalbuen 26", "postal_code": "2750", "city": "Ballerup"}]
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM internet_connections_connections" in query and "WHERE id = %s" in query:
+            return {"address": "Metalbuen 26, 2750 Ballerup", "allocation_model": "dedicated"}
+        if "FROM internet_connections_pricing" in query:
+            return None
+        if "FROM internet_connections_ip_ranges" in query:
+            return None
+        if "COUNT(*) AS total" in query and "FROM internet_connections_ip_addresses" in query:
+            return {"total": 0}
+        if "FROM internet_connections_ip_addresses" in query and "WHERE ip_address = %s" in query:
+            return None
+        return None
+
+    def fake_execute_query(query, params=None):
+        if "FROM internet_connections_connections" in query:
+            return []
+        if "FROM internet_connections_ip_ranges" in query:
+            return []
+        return []
+
+    def fake_execute_insert(query, params=None):
+        if "INSERT INTO internet_connections_connections" in query:
+            created_connections.append(params)
+            return 501
+        if "INSERT INTO internet_connections_ip_ranges" in query:
+            created_ranges.append(params)
+            return 601
+        return 1
+
+    def fake_execute_update(query, params=None):
+        if "INSERT INTO internet_connections_ip_addresses" in query:
+            ensured_ranges.append(params[0])
+        return 1
+
+    monkeypatch.setattr(supplier_module, "_load_extraction_lines", fake_load_lines)
+    monkeypatch.setattr(supplier_module, "_load_active_customers_for_matching", fake_load_customers)
+    monkeypatch.setattr(supplier_module, "execute_query", fake_execute_query)
+    monkeypatch.setattr(supplier_module, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(supplier_module, "execute_insert", fake_execute_insert)
+    monkeypatch.setattr(supplier_module, "execute_update", fake_execute_update)
+
+    result = supplier_module._sync_globalconnect_extraction_to_internet(extraction)
+
+    assert result["skipped"] is False
+    assert result["connections_synced"] == 1
+    assert result["connections_synced"] == 1
+    assert created_connections
+    assert created_ranges
+    assert ensured_ranges
+    assert created_connections[0][0] == "Malerfirmaet Gert Jensen ApS"
+    assert created_connections[0][9] == 100
+    assert created_connections[0][10] == 100
+    assert created_connections[0][11] == 100
+    assert created_connections[0][13] == "dedicated"
+    assert created_connections[0][14] == "other"
+    assert created_ranges[0][2] == "152.115.84.232/29"
+
+
+def test_sync_globalconnect_infers_dsl_kbps_speed(monkeypatch):
+    created_connections = []
+
+    extraction = {
+        "extraction_id": 175,
+        "vendor_name": "GlobalConnect A/S",
+        "document_id": "3016392",
+        "document_date": "2026-01-01",
+        "llm_response_json": {"template": "dk.globalconnect"},
+    }
+    lines = [
+        {
+            "description": "20480/2048 Kbps ADSL forbindelse",
+            "provider_reference": "DSL-EB680288",
+            "circuit_id": "DSL-EB680288",
+            "line_total": 420.0,
+            "unit_price": 140.0,
+            "quantity": 3,
+            "end_customer_name": "Malerfirmaet Gert Jensen ApS",
+            "service_address": "Metalbuen 26, 2750 Ballerup",
+        }
+    ]
+
+    monkeypatch.setattr(supplier_module, "_load_extraction_lines", lambda _: lines)
+    monkeypatch.setattr(
+        supplier_module,
+        "_load_active_customers_for_matching",
+        lambda: [{"id": 322, "name": "Malerfirmaet Gert Jensen ApS", "address": "Metalbuen 26", "postal_code": "2750", "city": "Ballerup"}],
+    )
+    monkeypatch.setattr(supplier_module, "execute_query", lambda query, params=None: [])
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM internet_connections_ip_addresses" in query:
+            return {"total": 0}
+        return None
+
+    monkeypatch.setattr(supplier_module, "execute_query_single", fake_execute_query_single)
+
+    def fake_execute_insert(query, params=None):
+        if "INSERT INTO internet_connections_connections" in query:
+            created_connections.append(params)
+            return 700
+        return 1
+
+    monkeypatch.setattr(supplier_module, "execute_insert", fake_execute_insert)
+    monkeypatch.setattr(supplier_module, "execute_update", lambda query, params=None: 1)
+
+    result = supplier_module._sync_globalconnect_extraction_to_internet(extraction)
+
+    assert result["connections_synced"] == 1
+    assert created_connections
+    assert created_connections[0][9] == 20
+    assert created_connections[0][10] == 2
+    assert created_connections[0][11] == 20
+
+
+def test_sync_globalconnect_marks_uncertain_connection_pending(monkeypatch):
+    extraction = {
+        "extraction_id": 176,
+        "vendor_name": "GlobalConnect A/S",
+        "document_id": "3018657",
+        "document_date": "2026-01-01",
+        "llm_response_json": {"template": "dk.globalconnect"},
+    }
+    lines = [
+        {
+            "description": "1 Gbps fiberforbindelse",
+            "provider_reference": "NKA020902",
+            "circuit_id": "NKA020902",
+            "line_total": 5417.4,
+            "unit_price": 1805.8,
+            "quantity": 3,
+            "end_customer_name": None,
+            "service_address": None,
+        }
+    ]
+
+    monkeypatch.setattr(supplier_module, "_load_extraction_lines", lambda _: lines)
+    monkeypatch.setattr(supplier_module, "_load_active_customers_for_matching", lambda: [])
+    monkeypatch.setattr(supplier_module, "execute_query", lambda query, params=None: [])
+
+    result = supplier_module._sync_globalconnect_extraction_to_internet(extraction)
+
+    assert result["connections_synced"] == 0
+    assert result["skipped_connection_lines"] == 1
+    assert result["verification"]["requires_manual_review"] is True
+    assert result["skipped_items"][0]["reason"] == "Mangler serviceadresse"
+
+
+def test_upsert_globalconnect_connection_requires_service_address(monkeypatch):
+    monkeypatch.setattr(supplier_module, "execute_query", lambda query, params=None: [])
+
+    connection_id = supplier_module._upsert_globalconnect_connection(
+        reference="NKA020902",
+        lines=[{
+            "description": "1 Gbps fiberforbindelse",
+            "provider_reference": "NKA020902",
+            "circuit_id": "NKA020902",
+            "line_total": 5417.4,
+            "unit_price": 1805.8,
+            "quantity": 3,
+            "end_customer_name": None,
+            "service_address": None,
+        }],
+        invoice_date="2026-01-01",
+        invoice_number="3018657",
+        customers=[],
+    )
+
+    assert connection_id is None
+
+
+def test_sync_globalconnect_assigns_shared_bmc_value_model(monkeypatch):
+    created_connections = []
+
+    extraction = {
+        "extraction_id": 176,
+        "vendor_name": "GlobalConnect A/S",
+        "document_id": "3018657",
+        "document_date": "2026-01-01",
+        "llm_response_json": {"template": "dk.globalconnect"},
+    }
+    lines = [
+        {
+            "description": "IPv4 IP-adresser",
+            "provider_reference": "NKA008225",
+            "circuit_id": "NKA008225",
+            "ip_address": "152.115.57.96/27",
+            "line_total": 768.0,
+            "unit_price": 256.0,
+            "quantity": 3,
+        }
+    ]
+
+    monkeypatch.setattr(supplier_module, "_load_extraction_lines", lambda _: lines)
+    monkeypatch.setattr(supplier_module, "_load_active_customers_for_matching", lambda: [])
+    monkeypatch.setattr(supplier_module, "_resolve_internal_bmc_customer", lambda: {"id": 1662, "name": "BMC Networks"})
+    monkeypatch.setattr(supplier_module, "execute_query", lambda query, params=None: [])
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM internet_connections_ip_addresses" in query:
+            return {"total": 0}
+        return None
+
+    monkeypatch.setattr(supplier_module, "execute_query_single", fake_execute_query_single)
+
+    def fake_execute_insert(query, params=None):
+        if "INSERT INTO internet_connections_connections" in query:
+            created_connections.append(params)
+            return 800
+        return 1
+
+    monkeypatch.setattr(supplier_module, "execute_insert", fake_execute_insert)
+    monkeypatch.setattr(supplier_module, "execute_update", lambda query, params=None: 1)
+
+    result = supplier_module._sync_globalconnect_extraction_to_internet(extraction)
+
+    assert result["connections_synced"] == 0
+    assert result["ip_ranges_synced"] == 0
+    assert result["skipped_orphan_ip_ranges"] == 1
+    assert created_connections == []
+
+
+def test_upsert_globalconnect_connection_assigns_delefiber_for_internal_shared_owner(monkeypatch):
+    created_connections = []
+    line = {
+        "description": "1 Gbps fiberforbindelse MPLS VPN",
+        "provider_reference": "NKA020900",
+        "circuit_id": "NKA020900",
+        "line_total": 4950.0,
+        "unit_price": 1650.0,
+        "quantity": 3,
+        "service_address": "Rydagervej 27, 2620 Albertslund",
+        "end_customer_name": "",
+    }
+
+    monkeypatch.setattr(supplier_module, "execute_query", lambda query, params=None: [])
+    monkeypatch.setattr(supplier_module, "_resolve_internal_bmc_customer", lambda: {"id": 1662, "name": "BMC Networks"})
+    monkeypatch.setattr(supplier_module, "_ensure_connection_pricing_entry", lambda **kwargs: None)
+    monkeypatch.setattr(supplier_module, "_append_connection_history", lambda *args, **kwargs: None)
+
+    def fake_execute_insert(query, params=None):
+        if "INSERT INTO internet_connections_connections" in query:
+            created_connections.append(params)
+            return 901
+        return 1
+
+    monkeypatch.setattr(supplier_module, "execute_insert", fake_execute_insert)
+
+    connection_id = supplier_module._upsert_globalconnect_connection(
+        reference="NKA020900",
+        lines=[line],
+        invoice_date="2026-01-01",
+        invoice_number="3018657",
+        customers=[],
+    )
+
+    assert connection_id == 901
+    assert created_connections
+    assert created_connections[0][2] == 1662
+    assert created_connections[0][-3] == "shared"
+    assert created_connections[0][-2] == "delefiber"
+
+
+def test_sync_globalconnect_attaches_ip_range_to_existing_connection(monkeypatch):
+    created_ranges = []
+
+    extraction = {
+        "extraction_id": 176,
+        "vendor_name": "GlobalConnect A/S",
+        "document_id": "3018657",
+        "document_date": "2026-01-01",
+        "llm_response_json": {"template": "dk.globalconnect"},
+    }
+    lines = [
+        {
+            "description": "IPv4 IP-adresser",
+            "provider_reference": "NKA008225",
+            "circuit_id": "NKA008225",
+            "ip_address": "152.115.57.96/27",
+            "line_total": 768.0,
+            "unit_price": 256.0,
+            "quantity": 3,
+            "service_address": "Metalbuen 26, 2750 Ballerup",
+        }
+    ]
+
+    monkeypatch.setattr(supplier_module, "_load_extraction_lines", lambda _: lines)
+    monkeypatch.setattr(supplier_module, "_load_active_customers_for_matching", lambda: [])
+    monkeypatch.setattr(
+        supplier_module,
+        "execute_query",
+        lambda query, params=None: [{"id": 16, "address": "Metalbuen 26, 2750 Ballerup"}] if "FROM internet_connections_connections" in query else [],
+    )
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM internet_connections_ip_ranges" in query:
+            return None
+        if "FROM internet_connections_ip_addresses" in query:
+            return {"total": 0}
+        return None
+
+    monkeypatch.setattr(supplier_module, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(supplier_module, "execute_insert", lambda query, params=None: 601 if "INSERT INTO internet_connections_ip_ranges" in query else 1)
+
+    def fake_execute_update(query, params=None):
+        return 1
+
+    monkeypatch.setattr(supplier_module, "execute_update", fake_execute_update)
+
+    result = supplier_module._sync_globalconnect_extraction_to_internet(extraction)
+
+    assert result["connections_synced"] == 0
+    assert result["ip_ranges_synced"] == 1
+    assert result["skipped_orphan_ip_ranges"] == 0
+    assert result["line_audit"][0]["result"] == "linked_existing_connection"
+
+
+def test_sync_globalconnect_normalizes_reference_without_dash(monkeypatch):
+    created_ranges = []
+
+    extraction = {
+        "extraction_id": 176,
+        "vendor_name": "GlobalConnect A/S",
+        "document_id": "3018657",
+        "document_date": "2026-01-01",
+        "llm_response_json": {"template": "dk.globalconnect"},
+    }
+    lines = [
+        {
+            "description": "IPv4 IP-adresser",
+            "provider_reference": "NKA008225",
+            "circuit_id": "NKA008225",
+            "ip_address": "152.115.57.96/27",
+            "line_total": 768.0,
+            "unit_price": 256.0,
+            "quantity": 3,
+            "service_address": "Metalbuen 26, 2750 Ballerup",
+        }
+    ]
+
+    monkeypatch.setattr(supplier_module, "_load_extraction_lines", lambda _: lines)
+    monkeypatch.setattr(supplier_module, "_load_active_customers_for_matching", lambda: [])
+    monkeypatch.setattr(
+        supplier_module,
+        "execute_query",
+        lambda query, params=None: [{"id": 32, "address": "Metalbuen 26, 2750 Ballerup"}] if "FROM internet_connections_connections" in query else [],
+    )
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM internet_connections_ip_ranges" in query:
+            return None
+        if "FROM internet_connections_ip_addresses" in query:
+            return {"total": 0}
+        return None
+
+    monkeypatch.setattr(supplier_module, "execute_query_single", fake_execute_query_single)
+    def fake_execute_insert(query, params=None):
+        if "INSERT INTO internet_connections_ip_ranges" in query:
+            created_ranges.append(params)
+            return 3
+        return 1
+
+    monkeypatch.setattr(supplier_module, "execute_insert", fake_execute_insert)
+    monkeypatch.setattr(supplier_module, "execute_update", lambda query, params=None: 1)
+
+    result = supplier_module._sync_globalconnect_extraction_to_internet(extraction)
+
+    assert result["ip_ranges_synced"] == 1
+    assert created_ranges
+    assert created_ranges[0][0] == 32
+
+
+def test_sync_globalconnect_merges_duplicate_connections(monkeypatch):
+    updates = []
+
+    extraction = {
+        "extraction_id": 176,
+        "vendor_name": "GlobalConnect A/S",
+        "document_id": "3018657",
+        "document_date": "2026-01-01",
+        "llm_response_json": {"template": "dk.globalconnect"},
+    }
+    lines = [
+        {
+            "description": "100 Mbps fiberforbindelse",
+            "provider_reference": "NKA008225",
+            "circuit_id": "NKA008225",
+            "line_total": 768.0,
+            "unit_price": 256.0,
+            "quantity": 3,
+            "service_address": "Metalbuen 26, 2750 Ballerup",
+        }
+    ]
+
+    monkeypatch.setattr(supplier_module, "_load_extraction_lines", lambda _: lines)
+    monkeypatch.setattr(supplier_module, "_load_active_customers_for_matching", lambda: [])
+
+    def fake_execute_query(query, params=None):
+        if "FROM internet_connections_connections" in query:
+            return [{"id": 16, "customer_id": None, "address": None}, {"id": 32, "customer_id": None, "address": None}]
+        if "FROM internet_connections_ip_ranges" in query:
+            return []
+        return []
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM internet_connections_ip_ranges" in query:
+            return None
+        if "FROM internet_connections_ip_addresses" in query:
+            return {"total": 0}
+        return None
+
+    monkeypatch.setattr(supplier_module, "execute_query", fake_execute_query)
+    monkeypatch.setattr(supplier_module, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(supplier_module, "execute_insert", lambda query, params=None: 3)
+    monkeypatch.setattr(supplier_module, "_ensure_internet_change_case", lambda **kwargs: 99)
+    monkeypatch.setattr(supplier_module, "_ensure_connection_pricing_entry", lambda **kwargs: None)
+
+    def fake_execute_update(query, params=None):
+        updates.append((query, params))
+        return 1
+
+    monkeypatch.setattr(supplier_module, "execute_update", fake_execute_update)
+
+    result = supplier_module._sync_globalconnect_extraction_to_internet(extraction)
+
+    assert result["connections_synced"] == 1
+    assert any(
+        "UPDATE internet_connections_ip_ranges" in query and params[0] == 16 and params[1] == 32
+        for query, params in updates
+    )
+    assert any(
+        "UPDATE internet_connections_connections" in query and params[1] == 32
+        for query, params in updates
+    )
+
+
+def test_sync_globalconnect_skips_reference_when_address_conflicts(monkeypatch):
+    extraction = {
+        "extraction_id": 176,
+        "vendor_name": "GlobalConnect A/S",
+        "document_id": "3018657",
+        "document_date": "2026-01-01",
+        "llm_response_json": {"template": "dk.globalconnect"},
+    }
+    lines = [
+        {
+            "description": "100 Mbps fiberforbindelse",
+            "provider_reference": "NKA008225",
+            "circuit_id": "NKA008225",
+            "line_total": 768.0,
+            "unit_price": 256.0,
+            "quantity": 3,
+            "service_address": "Metalbuen 26, 2750 Ballerup",
+        }
+    ]
+
+    monkeypatch.setattr(supplier_module, "_load_extraction_lines", lambda _: lines)
+    monkeypatch.setattr(supplier_module, "_load_active_customers_for_matching", lambda: [])
+    monkeypatch.setattr(
+        supplier_module,
+        "execute_query",
+        lambda query, params=None: [{"id": 16, "address": "Andenvej 99, 2100 København Ø"}] if "FROM internet_connections_connections" in query else [],
+    )
+
+    result = supplier_module._sync_globalconnect_extraction_to_internet(extraction)
+
+    assert result["connections_synced"] == 0
+    assert result["verification"]["requires_manual_review"] is True
+    assert "anden adresse" in result["skipped_items"][0]["reason"].lower()
+
+
+def test_sync_globalconnect_skips_ip_range_when_connection_reference_has_other_service_address(monkeypatch):
+    extraction = {
+        "extraction_id": 180,
+        "vendor_name": "GlobalConnect A/S",
+        "document_id": "3018657",
+        "document_date": "2026-01-01",
+        "llm_response_json": {"template": "dk.globalconnect"},
+    }
+    lines = [
+        {
+            "description": "1 Gbps fiberforbindelse MPLS VPN",
+            "provider_reference": "NKA020900",
+            "circuit_id": "NKA020900",
+            "line_total": 4950.0,
+            "unit_price": 1650.0,
+            "quantity": 3,
+            "service_address": "Rydagervej 27, 2620 Albertslund",
+        },
+        {
+            "description": "IPv4 IP-adresser",
+            "provider_reference": "NKA-020900",
+            "circuit_id": "NKA-020900",
+            "ip_address": "87.116.1.200/29",
+            "line_total": 384.0,
+            "unit_price": 128.0,
+            "quantity": 3,
+            "service_address": "Tobaksvejen 25, 2860 Søborg",
+        },
+    ]
+
+    monkeypatch.setattr(supplier_module, "_load_extraction_lines", lambda _: lines)
+    monkeypatch.setattr(supplier_module, "_load_active_customers_for_matching", lambda: [])
+    monkeypatch.setattr(supplier_module, "_ensure_connection_pricing_entry", lambda **kwargs: None)
+    monkeypatch.setattr(supplier_module, "_append_connection_history", lambda *args, **kwargs: None)
+    monkeypatch.setattr(supplier_module, "_ensure_internet_change_case", lambda **kwargs: None)
+
+    def fake_execute_query(query, params=None):
+        if "FROM internet_connections_connections" in query:
+            if "regexp_replace(UPPER(COALESCE(circuit_number, ''))" in query:
+                return []
+            return []
+        if "FROM internet_connections_ip_ranges" in query:
+            return []
+        return []
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM customers" in query:
+            return None
+        if "FROM internet_connections_connections" in query and "WHERE id = %s" in query:
+            return {
+                "address": "Rydagervej 27, 2620 Albertslund",
+                "allocation_model": "dedicated",
+            }
+        if "FROM internet_connections_ip_ranges" in query:
+            return None
+        if "FROM internet_connections_ip_addresses" in query:
+            return {"total": 0}
+        return None
+
+    created_connections = []
+
+    def fake_execute_insert(query, params=None):
+        if "INSERT INTO internet_connections_connections" in query:
+            created_connections.append(params)
+            return 96
+        if "INSERT INTO internet_connections_ip_ranges" in query:
+            raise AssertionError("IP-range should not be created when service address conflicts")
+        return 1
+
+    monkeypatch.setattr(supplier_module, "execute_query", fake_execute_query)
+    monkeypatch.setattr(supplier_module, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(supplier_module, "execute_insert", fake_execute_insert)
+    monkeypatch.setattr(supplier_module, "execute_update", lambda query, params=None: 1)
+
+    result = supplier_module._sync_globalconnect_extraction_to_internet(extraction)
+
+    assert result["connections_synced"] == 1
+    assert result["ip_ranges_synced"] == 0
+    assert result["skipped_orphan_ip_ranges"] == 1
+    assert created_connections
+    skipped_ip_entries = [entry for entry in result["line_audit"] if entry["classification"] == "ip_range"]
+    assert skipped_ip_entries
+    assert skipped_ip_entries[0]["status"] == "skipped"
+    assert "ingen forbindelse fundet" in (skipped_ip_entries[0]["reason"] or "").lower()
+
+
+def test_upsert_globalconnect_connection_logs_changes_and_creates_case(monkeypatch):
+    history_calls = []
+    case_calls = []
+    updates = []
+
+    customer = {
+        "id": 322,
+        "name": "Malerfirmaet Gert Jensen ApS",
+        "address": "Metalbuen 26",
+        "postal_code": "2750",
+        "city": "Ballerup",
+    }
+    line = {
+        "description": "200 Mbps fiberforbindelse",
+        "provider_reference": "NKA008214",
+        "circuit_id": "NKA008214",
+        "line_total": 360.0,
+        "unit_price": 120.0,
+        "quantity": 3,
+        "end_customer_name": "Malerfirmaet Gert Jensen ApS",
+        "service_address": "Metalbuen 26, 2750 Ballerup",
+    }
+
+    def fake_execute_query(query, params=None):
+        if "FROM internet_connections_connections" in query:
+            return [
+                {
+                    "id": 16,
+                    "customer_id": 322,
+                    "address": "Metalbuen 26, 2750 Ballerup",
+                    "monthly_cost": Decimal("100.00"),
+                    "technology": "Fiber",
+                    "connection_type": "fiber",
+                    "circuit_number": "NKA008214",
+                    "speed_mbps": 100,
+                    "download_mbps": 100,
+                    "upload_mbps": 100,
+                    "status": "active",
+                    "allocation_model": "dedicated",
+                    "value_type": "other",
+                    "value_label": None,
+                }
+            ]
+        return []
+
+    monkeypatch.setattr(supplier_module, "execute_query", fake_execute_query)
+    monkeypatch.setattr(supplier_module, "execute_update", lambda query, params=None: updates.append((query, params)) or 1)
+    monkeypatch.setattr(supplier_module, "_append_connection_history", lambda *args: history_calls.append(args))
+    monkeypatch.setattr(supplier_module, "_ensure_internet_change_case", lambda **kwargs: case_calls.append(kwargs) or 91)
+    monkeypatch.setattr(supplier_module, "_ensure_connection_pricing_entry", lambda **kwargs: None)
+
+    connection_id = supplier_module._upsert_globalconnect_connection(
+        reference="NKA008214",
+        lines=[line],
+        invoice_date="2026-01-01",
+        invoice_number="3018657",
+        customers=[customer],
+    )
+
+    assert connection_id == 16
+    assert updates
+    assert history_calls
+    assert history_calls[0][1] == "supplier_invoice_sync_changed"
+    assert history_calls[0][3]["changes"]["monthly_cost"] == {"from": "100.00", "to": "120.00"}
+    assert history_calls[0][3]["changes"]["speed_mbps"] == {"from": "100", "to": "200"}
+    assert case_calls
+    assert case_calls[0]["connection_id"] == 16
+    assert case_calls[0]["changes"]["download_mbps"] == {"from": "100", "to": "200"}
+
+
+def test_upsert_globalconnect_ip_range_logs_changes_and_creates_case(monkeypatch):
+    history_calls = []
+    case_calls = []
+    customer = {
+        "id": 322,
+        "name": "Malerfirmaet Gert Jensen ApS",
+        "address": "Metalbuen 26",
+        "postal_code": "2750",
+        "city": "Ballerup",
+    }
+    line = {
+        "description": "IPv4 IP-adresser",
+        "provider_reference": "NKA008214",
+        "circuit_id": "NKA008214",
+        "contract_number": "GC-NEW",
+        "ip_address": "152.115.84.232/29",
+        "line_total": 240.0,
+        "unit_price": 80.0,
+        "quantity": 3,
+        "end_customer_name": "Malerfirmaet Gert Jensen ApS",
+        "service_address": "Metalbuen 26, 2750 Ballerup",
+    }
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM internet_connections_ip_ranges" in query:
+            return {
+                "id": 88,
+                "provider_reference": "NKA008214",
+                "contract_number": "GC-OLD",
+                "customer_id": None,
+                "service_address": "Gammel adresse 1, 2000 Frederiksberg",
+                "monthly_cost": Decimal("64.00"),
+            }
+        if "FROM internet_connections_ip_addresses" in query:
+            return {"total": 6}
+        return None
+
+    monkeypatch.setattr(supplier_module, "execute_query", lambda query, params=None: [])
+    monkeypatch.setattr(supplier_module, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(supplier_module, "execute_update", lambda query, params=None: 1)
+    monkeypatch.setattr(supplier_module, "_append_connection_history", lambda *args: history_calls.append(args))
+    monkeypatch.setattr(supplier_module, "_ensure_internet_change_case", lambda **kwargs: case_calls.append(kwargs) or 92)
+    monkeypatch.setattr(supplier_module, "_ensure_ip_addresses_for_range", lambda range_id, cidr: 6)
+    monkeypatch.setattr(supplier_module, "_load_active_customers_for_matching", lambda: [customer])
+
+    range_id = supplier_module._upsert_globalconnect_ip_range(16, line, "3018657")
+
+    assert range_id == 88
+    assert history_calls
+    assert history_calls[0][1] == "supplier_invoice_ip_range_changed"
+    assert history_calls[0][3]["changes"]["contract_number"] == {"from": "GC-OLD", "to": "GC-NEW"}
+    assert history_calls[0][3]["changes"]["monthly_cost"] == {"from": "64.00", "to": "80.00"}
+    assert case_calls
+    assert case_calls[0]["reference"] == "NKA008214"
+    assert case_calls[0]["changes"]["service_address"]["to"] == "Metalbuen 26, 2750 Ballerup"
+
+
+def test_supplier_sync_skips_ip_addresses_that_already_exist(monkeypatch):
+    inserted = []
+
+    def fake_execute_query_single(query, params=None):
+        if "COUNT(*) AS total" in query and "internet_connections_ip_addresses" in query:
+            return {"total": 0}
+        if "FROM internet_connections_ip_addresses" in query and "WHERE ip_address = %s" in query:
+            if params[0] == "152.115.84.233":
+                return {"id": 91}
+            return None
+        return None
+
+    def fake_execute_update(query, params=None):
+        if "INSERT INTO internet_connections_ip_addresses" in query:
+            inserted.append(params[1])
+        return 1
+
+    monkeypatch.setattr(supplier_module, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(supplier_module, "execute_update", fake_execute_update)
+
+    created = supplier_module._ensure_ip_addresses_for_range(601, "152.115.84.232/30")
+
+    assert created == 1
+    assert inserted == ["152.115.84.234"]
+
+
+def test_append_amount_validation_case_note_creates_system_comment(monkeypatch):
+    comments = []
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM sag_kommentarer" in query:
+            return None
+        return None
+
+    def fake_execute_update(query, params=None):
+        if "INSERT INTO sag_kommentarer" in query:
+            comments.append(params)
+        return 1
+
+    monkeypatch.setattr(supplier_module, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(supplier_module, "execute_update", fake_execute_update)
+
+    supplier_module._append_amount_validation_case_note(
+        sag_id=91,
+        invoice_id=17,
+        invoice_number="3018657",
+        validation_details={
+            "line_sum": 600.0,
+            "subtotal": 800.0,
+            "difference": 200.0,
+            "vat_amount": 200.0,
+            "vat_expected": 200.0,
+            "vat_difference": 0.0,
+        },
+        validation_warning="Varelinjer sum (600.00) passer ikke med subtotal (800.00)",
+        vat_warning=None,
+        file_id=176,
+    )
+
+    assert comments
+    assert comments[0][0] == 91
+    assert "Subtotal-advarsel" in comments[0][2]
+    assert "Afvigelse: 200.0" in comments[0][2]
diff --git a/tests/test_internet_connections_module.py b/tests/test_internet_connections_module.py
new file mode 100644
index 0000000..337cc35
--- /dev/null
+++ b/tests/test_internet_connections_module.py
@@ -0,0 +1,661 @@
+import sys
+import asyncio
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from fastapi.testclient import TestClient
+
+from main import app
+
+
+def test_internet_connections_module_routes_are_available():
+    client = TestClient(app)
+
+    health_response = client.get('/api/v1/internet-connections/health')
+    assert health_response.status_code == 200
+    assert health_response.json()['service'] == 'internet-connections-module'
+
+    page_response = client.get('/economy/internet-connections')
+    assert page_response.status_code == 200
+    assert (
+        'Internetforbindelser' in page_response.text
+        or "window.location.href = '/login'" in page_response.text
+    )
+
+    detail_response = client.get('/economy/internet-connections/1')
+    assert detail_response.status_code == 200
+    assert (
+        'IP-ranges' in detail_response.text
+        or "window.location.href = '/login'" in detail_response.text
+    )
+
+
+def test_create_ip_range_rejects_invalid_cidr(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.post('/api/v1/internet-connections/2/ip-ranges', json={
+        'name': 'LAN',
+        'cidr': 'not-a-cidr',
+        'description': 'Test range',
+    })
+
+    assert response.status_code == 400
+    assert 'CIDR' in response.json()['detail']
+
+
+def test_create_connection_requires_address(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    monkeypatch.setattr(internet_router, 'execute_query', lambda query, params=None: [])
+
+    client = TestClient(app)
+    response = client.post('/api/v1/internet-connections', json={
+        'name': 'Uden adresse',
+        'provider': 'GlobalConnect A/S',
+        'status': 'active',
+        'allocation_model': 'shared',
+        'value_type': 'bmc_networks',
+    })
+
+    assert response.status_code == 400
+    assert 'address is required' in response.json()['detail']
+
+
+def test_list_ip_ranges_includes_ipam_details(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        if 'FROM internet_connections_ip_ranges' in query:
+            return [{
+                'id': 9,
+                'connection_id': 2,
+                'name': 'LAN',
+                'cidr': '10.0.0.0/24',
+                'description': 'Test range',
+            }]
+        if 'FROM internet_connections_ip_addresses' in query:
+            return [{
+                'id': 1,
+                'range_id': 9,
+                'ip_address': '10.0.0.1',
+                'status': 'in_use',
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.get('/api/v1/internet-connections/2/ip-ranges')
+
+    assert response.status_code == 200
+    payload = response.json()[0]
+    assert payload['network_address'] == '10.0.0.0'
+    assert payload['usable_hosts'] == 254
+    assert payload['used_addresses'] == 1
+
+
+def test_migration_wizard_v2_query_requires_real_segment_match(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        if "FROM internet_connections_customer_documents" in query:
+            return [{
+                "id": 101,
+                "customer_id": 77,
+                "connection_id": None,
+                "original_filename": "management_net.txt",
+                "filename": "management_net.txt",
+                "file_size": 1024,
+                "mime_type": "text/plain",
+                "extracted_text": "1 UNTAGGED Native Management\nVlan 50 Not in Use\nIP Informationer",
+                "notes": None,
+                "created_at": None,
+            }]
+        if "FROM internet_connections_customer_document_segments" in query:
+            return [{
+                "id": 201,
+                "document_id": 101,
+                "block_index": 0,
+                "block_title": "IP Informationer",
+                "content": "1 UNTAGGED Native Management\nVlan 50 Not in Use\nIP Informationer",
+                "ip_addresses": [],
+                "cidr_blocks": [],
+                "references_json": [],
+                "socket_numbers": [],
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, "execute_query", fake_execute_query)
+    monkeypatch.setattr(internet_router, "_ensure_document_segments", lambda document_id, extracted_text: 1)
+
+    payload = asyncio.run(internet_router._build_customer_document_hits(77, "Karise", "stageone"))
+
+    assert payload["segments"] == []
+    assert payload["documents"] == []
+
+
+def test_migration_wizard_v2_query_keeps_precise_segment_hits(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        if "FROM internet_connections_customer_documents" in query:
+            return [{
+                "id": 102,
+                "customer_id": 77,
+                "connection_id": None,
+                "original_filename": "karise.txt",
+                "filename": "karise.txt",
+                "file_size": 2048,
+                "mime_type": "text/plain",
+                "extracted_text": "StageOne uplink til Karise\nPort 1 StageOne WAN U20",
+                "notes": None,
+                "created_at": None,
+            }]
+        if "FROM internet_connections_customer_document_segments" in query:
+            return [{
+                "id": 202,
+                "document_id": 102,
+                "block_index": 0,
+                "block_title": "StageOne uplink til Karise",
+                "content": "StageOne uplink til Karise\nPort 1 StageOne WAN U20",
+                "ip_addresses": [],
+                "cidr_blocks": [],
+                "references_json": [],
+                "socket_numbers": ["U20"],
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, "execute_query", fake_execute_query)
+    monkeypatch.setattr(internet_router, "_ensure_document_segments", lambda document_id, extracted_text: 1)
+
+    payload = asyncio.run(internet_router._build_customer_document_hits(77, "Karise", "stageone"))
+
+    assert len(payload["segments"]) == 1
+    assert payload["segments"][0]["title"] == "StageOne uplink til Karise"
+    assert payload["documents"][0]["snippet_count"] == 1
+
+
+def test_create_ip_range_auto_generates_addresses_from_cidr(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    created_addresses = []
+
+    def fake_execute_query(query, params=None):
+        if 'INSERT INTO internet_connections_ip_ranges' in query:
+            return [{
+                'id': 15,
+                'connection_id': 2,
+                'name': 'LAN',
+                'cidr': '192.168.1.0/30',
+                'description': 'Auto generated',
+            }]
+        if 'INSERT INTO internet_connections_ip_addresses' in query:
+            created_addresses.append(params[1])
+            return [{
+                'id': len(created_addresses),
+                'range_id': 15,
+                'ip_address': params[1],
+                'status': 'available',
+            }]
+        if 'INSERT INTO internet_connections_history' in query:
+            return [{
+                'id': 20,
+                'connection_id': 2,
+                'event_type': 'ip_range_created',
+                'summary': 'Created IP range',
+                'details': {},
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.post('/api/v1/internet-connections/2/ip-ranges', json={
+        'name': 'LAN',
+        'cidr': '192.168.1.0/30',
+        'description': 'Auto generated',
+    })
+
+    assert response.status_code == 200
+    assert len(created_addresses) == 2
+    assert created_addresses == ['192.168.1.1', '192.168.1.2']
+
+
+def test_create_ip_range_skips_duplicate_existing_ip_addresses(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    created_addresses = []
+
+    def fake_execute_query(query, params=None):
+        if 'INSERT INTO internet_connections_ip_ranges' in query:
+            return [{
+                'id': 15,
+                'connection_id': 2,
+                'name': 'LAN',
+                'cidr': '192.168.1.0/30',
+                'description': 'Auto generated',
+            }]
+        if 'FROM internet_connections_ip_addresses' in query and 'WHERE ip_address = %s' in query:
+            if params[0] == '192.168.1.1':
+                return [{'id': 99, 'ip_address': '192.168.1.1'}]
+            return []
+        if 'INSERT INTO internet_connections_ip_addresses' in query:
+            created_addresses.append(params[1])
+            return [{
+                'id': len(created_addresses),
+                'range_id': 15,
+                'ip_address': params[1],
+                'status': 'available',
+            }]
+        if 'INSERT INTO internet_connections_history' in query:
+            return [{'id': 20}]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.post('/api/v1/internet-connections/2/ip-ranges', json={
+        'name': 'LAN',
+        'cidr': '192.168.1.0/30',
+        'description': 'Auto generated',
+    })
+
+    assert response.status_code == 200
+    assert created_addresses == ['192.168.1.2']
+
+
+def test_update_ip_address_status_changes_record(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    updated = []
+
+    def fake_execute_query(query, params=None):
+        if 'UPDATE internet_connections_ip_addresses' in query:
+            updated.append(params)
+            return [{'id': 4, 'status': 'reserved'}]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.put('/api/v1/internet-connections/2/ip-addresses/4', json={
+        'status': 'reserved',
+        'assigned_to': 'Test device',
+        'comment': 'Reserved for switch',
+    })
+
+    assert response.status_code == 200
+    assert updated[0][0] == 'reserved'
+    assert updated[0][1] == 'Test device'
+
+
+def test_create_ip_address_rejects_duplicate_ip(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        if 'FROM internet_connections_ip_addresses' in query and 'WHERE ip_address = %s' in query:
+            return [{'id': 4, 'range_id': 2}]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.post('/api/v1/internet-connections/2/ip-addresses', json={
+        'range_id': 7,
+        'ip_address': '10.0.0.10',
+        'status': 'available',
+    })
+
+    assert response.status_code == 409
+    assert 'findes allerede' in response.json()['detail']
+
+
+def test_list_ip_addresses_returns_structured_payload(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        if 'FROM internet_connections_ip_addresses' in query and 'JOIN internet_connections_ip_ranges' in query:
+            return [{
+                'id': 7,
+                'range_id': 3,
+                'ip_address': '10.0.0.10',
+                'status': 'in_use',
+                'assigned_to': 'Router',
+                'assigned_type': 'device',
+                'comment': 'Main gateway',
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.get('/api/v1/internet-connections/2/ip-addresses')
+
+    assert response.status_code == 200
+    payload = response.json()[0]
+    assert payload['status_label'] == 'I brug'
+    assert payload['badge_class'] == 'bg-primary'
+
+
+def test_create_ip_range_writes_history(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    calls = []
+
+    def fake_execute_query(query, params=None):
+        calls.append((query, params))
+        if 'INSERT INTO internet_connections_ip_ranges' in query:
+            return [{
+                'id': 1,
+                'connection_id': 2,
+                'name': 'LAN',
+                'cidr': '10.0.0.0/24',
+                'description': 'Test range',
+            }]
+        if 'INSERT INTO internet_connections_history' in query:
+            return [{
+                'id': 11,
+                'connection_id': 2,
+                'event_type': 'ip_range_created',
+                'summary': 'Created IP range',
+                'details': {},
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.post('/api/v1/internet-connections/2/ip-ranges', json={
+        'name': 'LAN',
+        'cidr': '10.0.0.0/24',
+        'description': 'Test range',
+    })
+
+    assert response.status_code == 200
+    assert any('INSERT INTO internet_connections_history' in query for query, _ in calls)
+
+
+def test_ip_address_status_summary_endpoint(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        if 'COUNT(*)' in query and 'internet_connections_ip_addresses' in query:
+            return [{
+                'available': 2,
+                'in_use': 1,
+                'reserved': 1,
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.get('/api/v1/internet-connections/2/ip-addresses/summary')
+
+    assert response.status_code == 200
+    assert response.json()['available'] == 2
+    assert response.json()['in_use'] == 1
+
+
+def test_pricing_history_can_be_created(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        if 'INSERT INTO internet_connections_pricing' in query:
+            return [{
+                'id': 7,
+                'connection_id': 2,
+                'effective_from': '2026-07-01',
+                'purchase_price': 1500,
+                'sales_price': 1800,
+                'notes': 'Ny aftale',
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.post('/api/v1/internet-connections/2/pricing', json={
+        'effective_from': '2026-07-01',
+        'purchase_price': 1500,
+        'sales_price': 1800,
+        'notes': 'Ny aftale',
+    })
+
+    assert response.status_code == 200
+    assert response.json()['sales_price'] == 1800
+
+
+def test_contract_overview_endpoint_reports_status(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        if 'FROM internet_connections_connections' in query and 'contract_end' in query:
+            return [{
+                'id': 3,
+                'name': 'Test connection',
+                'provider': 'BMC',
+                'contract_start': '2025-01-01',
+                'contract_end': '2025-12-31',
+                'status': 'active',
+                'sales_price': 900,
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.get('/api/v1/internet-connections/contracts')
+
+    assert response.status_code == 200
+    assert response.json()[0]['contract_status'] == 'expired'
+
+
+def test_contract_overview_endpoint_supports_status_filter(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        if 'status = %s' in query:
+            return [{
+                'id': 4,
+                'name': 'Filtered contract',
+                'provider': 'Nordic',
+                'contract_start': '2026-01-01',
+                'contract_end': '2026-12-31',
+                'status': 'active',
+                'sales_price': 1200,
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.get('/api/v1/internet-connections/contracts', params={'status': 'active'})
+
+    assert response.status_code == 200
+    assert response.json()[0]['status'] == 'active'
+
+
+def test_contract_overview_page_contains_table_controls():
+    client = TestClient(app)
+    response = client.get('/economy/internet-connections')
+
+    assert response.status_code == 200
+    assert (
+        'connectionsTableBody' in response.text
+        or "window.location.href = '/login'" in response.text
+    )
+    assert (
+        'pageSummaryText' in response.text
+        or "window.location.href = '/login'" in response.text
+    )
+
+
+def test_contract_overview_returns_empty_list_when_query_fails(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fail_execute_query(query, params=None):
+        raise RuntimeError('database unavailable')
+
+    monkeypatch.setattr(internet_router, 'execute_query', fail_execute_query)
+
+    client = TestClient(app)
+    response = client.get('/api/v1/internet-connections/contracts')
+
+    assert response.status_code == 200
+    assert response.json() == []
+
+
+def test_list_connections_returns_empty_list_when_query_fails(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fail_execute_query(query, params=None):
+        raise RuntimeError('database unavailable')
+
+    monkeypatch.setattr(internet_router, 'execute_query', fail_execute_query)
+
+    client = TestClient(app)
+    response = client.get('/api/v1/internet-connections')
+
+    assert response.status_code == 200
+    assert response.json() == []
+
+
+def test_pricing_summary_returns_zeroes_when_query_fails(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fail_execute_query(query, params=None):
+        raise RuntimeError('database unavailable')
+
+    monkeypatch.setattr(internet_router, 'execute_query', fail_execute_query)
+
+    client = TestClient(app)
+    response = client.get('/api/v1/internet-connections/pricing/summary')
+
+    assert response.status_code == 200
+    assert response.json() == {
+        'total_connections': 0,
+        'active_connections': 0,
+        'shared_head_connections': 0,
+        'total_purchase_cost': 0,
+        'total_sales_price': 0,
+        'total_margin': 0,
+    }
+
+
+def test_create_connection_requires_subscription_id_for_subscription_value(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    monkeypatch.setattr(internet_router, 'execute_query', lambda query, params=None: [])
+
+    client = TestClient(app)
+    response = client.post('/api/v1/internet-connections', json={
+        'name': 'Shared transit',
+        'address': 'Testvej 1, 8000 Aarhus C',
+        'allocation_model': 'shared',
+        'value_type': 'subscription',
+    })
+
+    assert response.status_code == 400
+    assert 'subscription_id' in response.json()['detail']
+
+
+def test_create_connection_requires_value_label_for_other(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    monkeypatch.setattr(internet_router, 'execute_query', lambda query, params=None: [])
+
+    client = TestClient(app)
+    response = client.post('/api/v1/internet-connections', json={
+        'name': 'Carrier edge',
+        'address': 'Testvej 1, 8000 Aarhus C',
+        'allocation_model': 'dedicated',
+        'value_type': 'other',
+    })
+
+    assert response.status_code == 400
+    assert 'value_label' in response.json()['detail']
+
+
+def test_list_connections_supports_shared_only_filter(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        assert "ic.allocation_model = 'shared' AND ic.parent_id IS NULL" in query
+        return [{
+            'id': 10,
+            'parent_id': None,
+            'name': 'BMC Networks · NKA008225',
+            'provider': 'GlobalConnect',
+            'customer_id': 1662,
+            'customer_name': 'BMC Networks',
+            'parent_name': None,
+            'address': None,
+            'status': 'active',
+            'monthly_cost': 256,
+            'sales_price': 0,
+            'margin_amount': -256,
+            'technology': 'Fiber',
+            'connection_type': 'fiber',
+            'circuit_number': 'NKA008225',
+            'speed_mbps': 100,
+            'upload_mbps': 100,
+            'download_mbps': 100,
+            'monitoring_url': None,
+            'contract_start': None,
+            'contract_end': None,
+            'allocation_model': 'shared',
+            'value_type': 'bmc_networks',
+            'value_label': None,
+            'subscription_id': None,
+            'subscription_number': None,
+            'subscription_product_name': None,
+            'subscription_customer_name': None,
+            'ip_range_count': 3,
+            'total_ip_addresses': 62,
+            'in_use_ip_addresses': 0,
+            'reserved_ip_addresses': 0,
+            'available_ip_addresses': 62,
+        }]
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.get('/api/v1/internet-connections', params={'shared_only': 'true'})
+
+    assert response.status_code == 200
+    payload = response.json()[0]
+    assert payload['allocation_model_label'] == 'Delt'
+    assert payload['value_type_label'] == 'BMC Networks'
+    assert payload['is_shared_head'] is True
+
+
+def test_subscription_options_endpoint_returns_lookup_rows(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query(query, params=None):
+        if 'FROM sag_subscriptions s' in query:
+            return [{
+                'id': 9,
+                'subscription_number': 'SUB-1001',
+                'product_name': 'Internet 1G',
+                'customer_id': 1662,
+                'customer_name': 'BMC Networks',
+                'status': 'active',
+            }]
+        return []
+
+    monkeypatch.setattr(internet_router, 'execute_query', fake_execute_query)
+
+    client = TestClient(app)
+    response = client.get('/api/v1/internet-connections/subscription-options', params={'q': '1G'})
+
+    assert response.status_code == 200
+    assert response.json()[0]['subscription_number'] == 'SUB-1001'
diff --git a/tests/test_invoice2data_globalconnect.py b/tests/test_invoice2data_globalconnect.py
new file mode 100644
index 0000000..674c50a
--- /dev/null
+++ b/tests/test_invoice2data_globalconnect.py
@@ -0,0 +1,116 @@
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from app.services.invoice2data_service import Invoice2DataService
+
+
+def test_globalconnect_parser_extracts_contextual_lines():
+    service = Invoice2DataService()
+    sample_text = """
+GlobalConnect A/S
+Kundenr. D30190
+Fakturanr. 3016392
+Bilagsdato 1. januar 2026
+Forfaldsdato 1. april 2026
+Kontrakt: 20292
+Vedr: DSL-EB722388
+Metalbuen 26 2750 Ballerup
+Slutkunde: MALERFIRMAET GERT JENSEN ApS VOIP
+Periode: 01-01-2026 - 31-03-2026
+20480/2048 Kbps ADSL forbindelse 3 Stk. 140,00 420,00
+Kontrakt: 20140005-00
+Vedr: IP adresser
+152.115.84.232/29 (NKA-008214)
+Industrivej 7 2605 Brondby
+IPv4 IP-adresser 3 Stk. 64,00 192,00
+I alt DKK ekskl. moms 612,00
+25% moms 153,00
+I alt DKK inkl. moms 765,00
+SE/CVR-nr. 26759722
+29522790
+""".strip()
+
+    extracted = service.extract_with_template(sample_text, "dk.globalconnect")
+
+    assert extracted["invoice_number"] == 3016392
+    assert extracted["invoice_date"] == "2026-01-01"
+    assert extracted["due_date"] == "2026-04-01"
+    assert extracted["customer_reference"] == "D30190"
+    assert extracted["vendor_vat"] == "26759722"
+    assert extracted["amount_total"] == 765.0
+    assert len(extracted["lines"]) == 2
+
+    first_line = extracted["lines"][0]
+    assert first_line["provider_reference"] == "DSL-EB722388"
+    assert first_line["contract_number"] == "20292"
+    assert first_line["end_customer_name"] == "MALERFIRMAET GERT JENSEN ApS VOIP"
+    assert first_line["period_start"] == "2026-01-01"
+    assert first_line["period_end"] == "2026-03-31"
+
+    second_line = extracted["lines"][1]
+    assert second_line["ip_address"] == "152.115.84.232/29"
+    assert second_line["provider_reference"] == "NKA-008214"
+    assert second_line["service_address"] == "Industrivej 7, 2605 Brondby"
+
+
+def test_validation_details_are_added_on_subtotal_mismatch():
+    service = Invoice2DataService()
+    extracted = {
+        "total_amount": 1000.0,
+        "vat_amount": 200.0,
+        "lines": [
+            {"line_total": 500.0},
+            {"line_total": 100.0},
+        ],
+    }
+
+    service._validate_amounts(extracted)
+
+    assert "_validation_warning" in extracted
+    assert extracted["_validation_details"]["line_sum"] == 600.0
+    assert extracted["_validation_details"]["subtotal"] == 800.0
+    assert extracted["_validation_details"]["difference"] == 200.0
+    assert extracted["_validation_details"]["subtotal_matches"] is False
+
+
+def test_globalconnect_parser_handles_split_address_and_mpls_multiline_context():
+    service = Invoice2DataService()
+    sample_text = """
+GlobalConnect A/S
+Kundenr. D30190
+Fakturanr. 3018657
+Bilagsdato 1. januar 2026
+Forfaldsdato 1. april 2026
+NKA020900
+Rydagervej 27
+2620 Albertslund
+1 Gbps fiberforbindelse 3 Måneder 1.650,00 4.950,00
+MPLS VPN (layer 3) Serviceaftale Døgn 3 Måneder
+1 Gbps Flatrate internet
+IPv4 IP-adresser 3 Stk. 64,00 192,00
+87.116.1.200/29 (NKA-020900)
+Rydagervej 27
+2620 Albertslund
+I alt DKK ekskl. moms 5.142,00
+25% moms 1.285,50
+I alt DKK inkl. moms 6.427,50
+SE/CVR-nr. 26759722
+29522790
+""".strip()
+
+    extracted = service.extract_with_template(sample_text, "dk.globalconnect")
+
+    assert len(extracted["lines"]) == 2
+
+    connection_line = extracted["lines"][0]
+    assert connection_line["provider_reference"] == "NKA020900"
+    assert connection_line["service_address"] == "Rydagervej 27, 2620 Albertslund"
+    assert "MPLS VPN" in connection_line["description"]
+    assert "1 Gbps Flatrate internet" in connection_line["description"]
+
+    ip_line = extracted["lines"][1]
+    assert ip_line["provider_reference"] == "NKA-020900"
+    assert ip_line["ip_address"] == "87.116.1.200/29"
+    assert ip_line["service_address"] == "Rydagervej 27, 2620 Albertslund"
diff --git a/tests/test_subscription_network_provisioning.py b/tests/test_subscription_network_provisioning.py
new file mode 100644
index 0000000..0b3e204
--- /dev/null
+++ b/tests/test_subscription_network_provisioning.py
@@ -0,0 +1,430 @@
+import sys
+import asyncio
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from fastapi.testclient import TestClient
+
+from main import app
+
+
+def test_subscription_by_sag_includes_network_provisioning(monkeypatch):
+    from app.subscriptions.backend import router as subscription_router
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM sag_subscriptions s" in query and "WHERE s.sag_id = %s" in query:
+            return {
+                "id": 44,
+                "subscription_number": "SUB-44",
+                "sag_id": 9,
+                "customer_id": 1662,
+                "customer_name": "BMC Networks",
+                "product_name": "BMCnet 100/100",
+                "billing_interval": "monthly",
+                "billing_day": 1,
+                "price": 499,
+                "start_date": "2026-07-01",
+                "end_date": None,
+                "status": "draft",
+                "notes": None,
+            }
+        if "FROM internet_connections_connections" in query and "subscription_id = %s" in query:
+            return None
+        return None
+
+    def fake_execute_query(query, params=None):
+        if "FROM sag_subscription_items i" in query:
+            return [
+                {
+                    "id": 100,
+                    "line_no": 1,
+                    "product_id": 501,
+                    "product_name": "BMCnet 100/100",
+                    "product_type": "service",
+                    "attributes_json": {"network": {"kind": "internet_access", "download_mbps": 100, "upload_mbps": 100}},
+                    "description": "BMCnet 100/100",
+                    "quantity": 1,
+                    "unit_price": 399,
+                    "line_total": 399,
+                    "period_from": None,
+                    "period_to": None,
+                    "requires_serial_number": False,
+                    "serial_number": None,
+                    "billing_blocked": False,
+                    "billing_block_reason": None,
+                },
+                {
+                    "id": 101,
+                    "line_no": 2,
+                    "product_id": 502,
+                    "product_name": "/30 IP",
+                    "product_type": "service",
+                    "attributes_json": {"network": {"kind": "ip_allocation", "ip_prefix_length": 30}},
+                    "description": "/30 IP",
+                    "quantity": 1,
+                    "unit_price": 100,
+                    "line_total": 100,
+                    "period_from": None,
+                    "period_to": None,
+                    "requires_serial_number": False,
+                    "serial_number": None,
+                    "billing_blocked": False,
+                    "billing_block_reason": None,
+                },
+            ]
+        return []
+
+    monkeypatch.setattr(subscription_router, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(subscription_router, "execute_query", fake_execute_query)
+
+    payload = asyncio.run(subscription_router.get_subscription_by_sag(9, True))
+    assert payload["requires_network_provisioning"] is True
+    assert payload["network_provisioning"]["internet_items"][0]["download_mbps"] == 100
+    assert payload["network_provisioning"]["ip_items"][0]["ip_prefix_length"] == 30
+
+
+def test_subscription_provisioning_endpoint_returns_shared_heads(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM sag_subscriptions s" in query:
+            return {
+                "id": 55,
+                "subscription_number": "SUB-55",
+                "sag_id": 7,
+                "customer_id": 21,
+                "customer_name": "Eksempel Kunde",
+                "product_name": "BMCnet 100/100",
+                "billing_interval": "monthly",
+                "price": 699,
+                "status": "draft",
+                "start_date": "2026-07-01",
+            }
+        return None
+
+    def fake_execute_query(query, params=None):
+        if "FROM sag_subscription_items i" in query:
+            return [
+                {
+                    "id": 201,
+                    "line_no": 1,
+                    "product_id": 601,
+                    "product_name": "BMCnet 100/100",
+                    "product_type": "service",
+                    "attributes_json": {"network": {"kind": "internet_access", "download_mbps": 100, "upload_mbps": 100}},
+                    "description": "BMCnet 100/100",
+                    "quantity": 1,
+                    "unit_price": 499,
+                    "line_total": 499,
+                },
+                {
+                    "id": 202,
+                    "line_no": 2,
+                    "product_id": 602,
+                    "product_name": "/30 IP",
+                    "product_type": "service",
+                    "attributes_json": {"network": {"kind": "ip_allocation", "ip_prefix_length": 30}},
+                    "description": "/30 IP",
+                    "quantity": 1,
+                    "unit_price": 200,
+                    "line_total": 200,
+                },
+            ]
+        if "ic.subscription_id = %s" in query:
+            return []
+        if "ic.allocation_model = 'shared'" in query:
+            return [
+                {
+                    "id": 88,
+                    "parent_id": None,
+                    "name": "BMC Networks · Albertslund",
+                    "provider": "GlobalConnect",
+                    "customer_id": 1662,
+                    "customer_name": "BMC Networks",
+                    "parent_name": None,
+                    "address": "Rydagervej 27, 2620 Albertslund",
+                    "status": "active",
+                    "monthly_cost": 0,
+                    "sales_price": 0,
+                    "margin_amount": 0,
+                    "technology": "Fiber",
+                    "connection_type": "fiber",
+                    "circuit_number": "NKA020900",
+                    "speed_mbps": 1000,
+                    "upload_mbps": 1000,
+                    "download_mbps": 1000,
+                    "monitoring_url": None,
+                    "contract_start": None,
+                    "contract_end": None,
+                    "allocation_model": "shared",
+                    "value_type": "bmc_networks",
+                    "value_label": None,
+                    "subscription_id": None,
+                    "subscription_number": None,
+                    "subscription_product_name": None,
+                    "subscription_customer_name": None,
+                    "ip_range_count": 1,
+                    "total_ip_addresses": 2,
+                    "in_use_ip_addresses": 0,
+                    "reserved_ip_addresses": 0,
+                    "available_ip_addresses": 2,
+                }
+            ]
+        if "FROM internet_connections_ip_ranges ir" in query and "GROUP BY ir.id, c.name" in query:
+            return [
+                {
+                    "id": 301,
+                    "connection_id": 88,
+                    "name": "87.116.1.200/30",
+                    "cidr": "87.116.1.200/30",
+                    "description": None,
+                    "provider_reference": "NKA020900",
+                    "contract_number": None,
+                    "customer_id": None,
+                    "service_address": "Rydagervej 27, 2620 Albertslund",
+                    "monthly_cost": 0,
+                    "sales_price": 0,
+                    "customer_name": None,
+                    "total_addresses": 2,
+                    "available_addresses": 2,
+                    "reserved_addresses": 0,
+                    "in_use_addresses": 0,
+                }
+            ]
+        return []
+
+    monkeypatch.setattr(internet_router, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(internet_router, "execute_query", fake_execute_query)
+
+    client = TestClient(app)
+    response = client.get("/api/v1/internet-connections/subscriptions/55/provisioning")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["network_provisioning"]["requires_provisioning"] is True
+    assert payload["shared_heads"][0]["address"] == "Rydagervej 27, 2620 Albertslund"
+    assert payload["shared_heads"][0]["available_matching_ranges"][0]["cidr"] == "87.116.1.200/30"
+
+
+def test_subscription_provisioning_endpoint_can_offer_derived_subrange(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM sag_subscriptions s" in query:
+            return {
+                "id": 56,
+                "subscription_number": "SUB-56",
+                "sag_id": 7,
+                "customer_id": 21,
+                "customer_name": "Eksempel Kunde",
+                "product_name": "BMCnet 500/500 + /28",
+                "billing_interval": "monthly",
+                "price": 699,
+                "status": "draft",
+                "start_date": "2026-07-01",
+            }
+        return None
+
+    def fake_execute_query(query, params=None):
+        if "FROM sag_subscription_items i" in query:
+            return [
+                {
+                    "id": 301,
+                    "line_no": 1,
+                    "product_id": 701,
+                    "product_name": "BMCnet 500/500",
+                    "product_type": "service",
+                    "attributes_json": {"network": {"kind": "internet_access", "download_mbps": 500, "upload_mbps": 500}},
+                    "description": "BMCnet 500/500",
+                    "quantity": 1,
+                    "unit_price": 499,
+                    "line_total": 499,
+                },
+                {
+                    "id": 302,
+                    "line_no": 2,
+                    "product_id": 702,
+                    "product_name": "/28 IP",
+                    "product_type": "service",
+                    "attributes_json": {"network": {"kind": "ip_allocation", "ip_prefix_length": 28}},
+                    "description": "/28 IP",
+                    "quantity": 1,
+                    "unit_price": 200,
+                    "line_total": 200,
+                },
+            ]
+        if "ic.subscription_id = %s" in query:
+            return []
+        if "ic.allocation_model = 'shared'" in query:
+            return [
+                {
+                    "id": 188,
+                    "parent_id": None,
+                    "name": "BMC Networks · Albertslund",
+                    "provider": "GlobalConnect",
+                    "customer_id": 1662,
+                    "customer_name": "BMC Networks",
+                    "parent_name": None,
+                    "address": "Rydagervej 27, 2620 Albertslund",
+                    "status": "active",
+                    "monthly_cost": 0,
+                    "sales_price": 0,
+                    "margin_amount": 0,
+                    "technology": "Fiber",
+                    "connection_type": "fiber",
+                    "circuit_number": "NKA020900",
+                    "speed_mbps": 1000,
+                    "upload_mbps": 1000,
+                    "download_mbps": 1000,
+                    "monitoring_url": None,
+                    "contract_start": None,
+                    "contract_end": None,
+                    "allocation_model": "shared",
+                    "value_type": "bmc_networks",
+                    "value_label": None,
+                    "subscription_id": None,
+                    "subscription_number": None,
+                    "subscription_product_name": None,
+                    "subscription_customer_name": None,
+                    "ip_range_count": 1,
+                    "total_ip_addresses": 62,
+                    "in_use_ip_addresses": 0,
+                    "reserved_ip_addresses": 0,
+                    "available_ip_addresses": 62,
+                }
+            ]
+        if "FROM internet_connections_ip_ranges ir" in query and "GROUP BY ir.id, c.name" in query:
+            return [
+                {
+                    "id": 401,
+                    "connection_id": 188,
+                    "name": "83.136.94.128/26",
+                    "cidr": "83.136.94.128/26",
+                    "description": None,
+                    "provider_reference": "NKA021047",
+                    "contract_number": None,
+                    "customer_id": None,
+                    "service_address": "Herstedvang 14, 2620 Albertslund",
+                    "monthly_cost": 0,
+                    "sales_price": 0,
+                    "customer_name": None,
+                    "total_addresses": 62,
+                    "available_addresses": 62,
+                    "reserved_addresses": 0,
+                    "in_use_addresses": 0,
+                }
+            ]
+        return []
+
+    monkeypatch.setattr(internet_router, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(internet_router, "execute_query", fake_execute_query)
+
+    client = TestClient(app)
+    response = client.get("/api/v1/internet-connections/subscriptions/56/provisioning")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["shared_heads"][0]["available_matching_range_count"] == 4
+    assert payload["shared_heads"][0]["available_matching_ranges"][0]["requested_cidr"].endswith("/28")
+    assert payload["shared_heads"][0]["available_matching_ranges"][0]["is_derived_candidate"] is True
+
+
+def test_subscription_provisioning_requires_ip_selection_for_each_ip_product(monkeypatch):
+    from app.modules.internet_connections.backend import router as internet_router
+
+    def fake_execute_query_single(query, params=None):
+        if "FROM sag_subscriptions s" in query:
+            return {
+                "id": 66,
+                "subscription_number": "SUB-66",
+                "sag_id": 8,
+                "customer_id": 77,
+                "customer_name": "Kunde",
+                "product_name": "BMCnet 100/100",
+                "billing_interval": "monthly",
+                "price": 799,
+                "status": "draft",
+                "start_date": "2026-07-01",
+            }
+        if "AND ic.id = %s AND ic.allocation_model = 'shared'" in query:
+            return {
+                "id": 90,
+                "parent_id": None,
+                "name": "BMC Networks · Shared",
+                "provider": "GlobalConnect",
+                "customer_id": 1662,
+                "customer_name": "BMC Networks",
+                "parent_name": None,
+                "address": "Adresse 1",
+                "status": "active",
+                "monthly_cost": 0,
+                "sales_price": 0,
+                "margin_amount": 0,
+                "technology": "Fiber",
+                "connection_type": "fiber",
+                "circuit_number": "NKA1",
+                "speed_mbps": 1000,
+                "upload_mbps": 1000,
+                "download_mbps": 1000,
+                "monitoring_url": None,
+                "contract_start": None,
+                "contract_end": None,
+                "allocation_model": "shared",
+                "value_type": "bmc_networks",
+                "value_label": None,
+                "subscription_id": None,
+                "subscription_number": None,
+                "subscription_product_name": None,
+                "subscription_customer_name": None,
+                "ip_range_count": 1,
+                "total_ip_addresses": 2,
+                "in_use_ip_addresses": 0,
+                "reserved_ip_addresses": 0,
+                "available_ip_addresses": 2,
+            }
+        return None
+
+    def fake_execute_query(query, params=None):
+        if "FROM sag_subscription_items i" in query:
+            return [
+                {
+                    "id": 210,
+                    "line_no": 1,
+                    "product_id": 610,
+                    "product_name": "BMCnet 100/100",
+                    "product_type": "service",
+                    "attributes_json": {"network": {"kind": "internet_access", "download_mbps": 100, "upload_mbps": 100}},
+                    "description": "BMCnet 100/100",
+                    "quantity": 1,
+                    "unit_price": 499,
+                    "line_total": 499,
+                },
+                {
+                    "id": 211,
+                    "line_no": 2,
+                    "product_id": 611,
+                    "product_name": "/30 IP",
+                    "product_type": "service",
+                    "attributes_json": {"network": {"kind": "ip_allocation", "ip_prefix_length": 30}},
+                    "description": "/30 IP",
+                    "quantity": 1,
+                    "unit_price": 300,
+                    "line_total": 300,
+                },
+            ]
+        if "ic.subscription_id = %s" in query:
+            return []
+        return []
+
+    monkeypatch.setattr(internet_router, "execute_query_single", fake_execute_query_single)
+    monkeypatch.setattr(internet_router, "execute_query", fake_execute_query)
+
+    client = TestClient(app)
+    response = client.post(
+        "/api/v1/internet-connections/subscriptions/66/provision",
+        json={"shared_connection_id": 90, "internet_item_id": 210, "ip_allocations": []},
+    )
+
+    assert response.status_code == 409
+    assert "IP-range" in response.json()["detail"]
diff --git a/updateto.sh b/updateto.sh
index 197f4d1..d04239e 100755
--- a/updateto.sh
+++ b/updateto.sh
@@ -190,6 +190,20 @@ if podman ps -a --format '{{.Names}} {{.Ports}}' | grep -E "${POSTGRES_BIND_ADDR
         done
 fi
 
+# Final raw socket guard: rootlessport can survive in a state where podman metadata
+# does not clearly show the holder yet the host port is still bound.
+if command -v ss >/dev/null 2>&1; then
+    if ss -ltn | awk '{print $4}' | grep -E "(^|:)${POSTGRES_PORT}$" >/dev/null 2>&1; then
+        echo "❌ Fejl: ${POSTGRES_BIND_ADDR}:${POSTGRES_PORT} lytter stadig paa hosten."
+        echo "   Det er typisk en gammel rootlessport-proxy eller en anden service."
+        echo "   Tjek med:"
+        echo "     ss -ltnp | grep :${POSTGRES_PORT}"
+        echo "     podman ps -a --format 'table {{.Names}}\\t{{.Status}}\\t{{.Ports}}'"
+        echo "   Loesning: stop/fjern holderen eller saet en anden POSTGRES_PORT i .env."
+        exit 1
+    fi
+fi
+
 # Stop containers
 echo ""
 echo "⏹️  Stopper containere..."