fix(ui): сохранять подтверждённый снимок пути при ошибке API

lib/dashboard-internet-path.ts

@@ -1,3 +1,4 @@
+import {readProbeOutput} from "@/lib/probe-response"
 import type { GreTunnel, Server, WanUplink } from "@/lib/data"
 import {
   assignSpeedProbesToGreTunnels,
@@ -152,18 +153,6 @@ function chooseActiveWan(
   return wans[0] ?? null
 }
 
-function syntheticWanForHome(home: Server): WanUplink {
-  return {
-    id: `wan-auto-${home.id}`,
-    name: "WAN-AUTO",
-    isp: "auto",
-    iface: "auto",
-    ip: home.host || "0.0.0.0",
-    maxDl: 100,
-    maxUl: 100,
-  }
-}
-
 function bestJhForWan(
   home: Server,
   wan: WanUplink,
@@ -293,11 +282,13 @@ export function buildDashboardInternetPath(args: {
       }
     : null
 
-  const activeWan = chooseActiveWan(
+  const observedRoute=Boolean(runtime?.defaultGateway||args.routeLookupByServerId[home.id]?.gateway)
+  const routeKnown=runtime!=null&&args.routeLookupByServerId[home.id]!=null
+  const activeWan = observedRoute ? chooseActiveWan(
     home,
     args.routeLookupByServerId[home.id] ?? null,
     runtime,
-  ) ?? syntheticWanForHome(home)
+  ) : null
   const currentJh = activeWan ? bestJhForWan(home, activeWan, jhs, args.probes) : null
   const currentExit = currentJh ? bestExitForJh(currentJh, exits, args.probes) : null
   const currentPath: InternetPathRoute | null = activeWan
@@ -308,7 +299,7 @@ export function buildDashboardInternetPath(args: {
     : null
 
   const pathState: InternetPathViewModel["pathState"] =
-    primaryPath && currentPath
+    !routeKnown||home.status==="unknown"||(currentJh?.status==="unknown")||(currentExit?.status==="unknown")?"unknown":primaryPath && currentPath
       // Нормальный production-кейс: часть трафика идет через BGP (JH→EN),
       // часть — напрямую в провайдера WAN uplink.
       ? "healthy"
@@ -431,15 +422,15 @@ export function buildDashboardInternetPath(args: {
     directWan: {
       enabled: Boolean(runtime?.defaultGateway || args.routeLookupByServerId[home.id]?.gateway),
       gateway: runtime?.defaultGateway ?? args.routeLookupByServerId[home.id]?.gateway ?? null,
-      iface: runtime?.defaultInterface ?? activeWan.iface ?? null,
+      iface: runtime?.defaultInterface ?? activeWan?.iface ?? null,
       leasedIp:
         runtime?.uplinks.find((u) => u.isDefault)?.leasedIp
-        ?? runtime?.uplinks.find((u) => norm(u.iface) === norm(activeWan.iface))?.leasedIp
+        ?? runtime?.uplinks.find((u) => norm(u.iface) === norm(activeWan?.iface))?.leasedIp
         ?? null,
       provider:
         runtime?.uplinks.find((u) => u.isDefault)?.isp
-        ?? runtime?.uplinks.find((u) => norm(u.iface) === norm(activeWan.iface))?.isp
-        ?? activeWan.isp
+        ?? runtime?.uplinks.find((u) => norm(u.iface) === norm(activeWan?.iface))?.isp
+        ?? activeWan?.isp
         ?? null,
     },
   }
@@ -449,8 +440,7 @@ export async function resolveDefaultRouteLookup(
   apiFetch: <T>(path: string, init?: RequestInit) => Promise<T>,
   serverId: string,
 ): Promise<RouteLookupResult | null> {
-  try {
-    const payload = await apiFetch<{ output?: string }>(`/api/servers/${serverId}/probes/run`, {
+  const payload = await apiFetch<unknown>(`/api/servers/${serverId}/probes/run`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -458,8 +448,5 @@ export async function resolveDefaultRouteLookup(
         target: INTERNET_TARGET,
       }),
     })
-    return parseRouteLookupOutput(payload.output ?? "")
-  } catch {
-    return null
-  }
+  return parseRouteLookupOutput(readProbeOutput(payload))
 }

lib/dashboard-path-response.test.ts

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict"
+import {test} from "node:test"
+import {parseDashboardPath,parseDashboardSpeedProbes,parseDashboardWanRuntime,parseDashboardFilters} from "./dashboard-path-response"
+import {resolveDefaultRouteLookup,buildDashboardInternetPath} from "./dashboard-internet-path"
+import {servers} from "./data"
+const snapshot={sampledAt:"2026-10-03T00:00:00Z",servers:[],greTunnels:[],filtersRulesets:[],speedProbes:[],routeLookupByServerId:{},wanRuntimeByHomeId:{}}
+test("path validates explicit empty snapshot and rejects missing fields, foreign IDs and mismatched time",()=>{
+ assert.deepEqual(parseDashboardPath({snapshot:null}),{snapshot:null});assert.ok(parseDashboardPath({snapshot}))
+ for(const raw of [{},{snapshot:{}},{snapshot:null,sampledAt:snapshot.sampledAt},{snapshot:{...snapshot,speedProbes:undefined}},{snapshot:{...snapshot,routeLookupByServerId:{"99":null}}},{snapshot,sampledAt:"2026-10-03T01:00:00Z"}])assert.throws(()=>parseDashboardPath(raw))
+})
+test("path fallback validates rules, speed probes and WAN rather than silently using empty data",()=>{
+ assert.ok(parseDashboardSpeedProbes({probes:[]}));assert.ok(parseDashboardFilters({rulesets:[]}));assert.ok(parseDashboardWanRuntime({defaultGateway:null,defaultInterface:null,uplinks:[]}))
+ for(const work of [()=>parseDashboardSpeedProbes({}),()=>parseDashboardFilters({rulesets:[],stale:true}),()=>parseDashboardWanRuntime({}),()=>parseDashboardWanRuntime({defaultGateway:null,defaultInterface:null,uplinks:[{}]})])assert.throws(work)
+})
+test("route diagnostic rejects malformed and error output; no route is a confirmed empty result",async()=>{
+ for(const raw of [{},{output:"Error: denied"},{output:12}])await assert.rejects(resolveDefaultRouteLookup(async<T>()=>raw as T,"1"))
+ assert.deepEqual(await resolveDefaultRouteLookup(async<T>()=>({output:""}) as T,"1"),{gateway:null,routingMark:null})
+})
+test("configured WAN alone does not prove an observed current route",()=>{
+ const mapped=servers.map((s,i)=>({...s,id:String(i+1)}));const result=buildDashboardInternetPath({servers:mapped,greTunnels:[],filtersRulesets:[],probes:[],routeLookupByServerId:{},wanRuntimeByHomeId:{}})
+ assert.ok(result);assert.equal(result.pathState,"unknown");assert.equal(result.currentPath,null);assert.equal(result.activeWanUplink,null)
+})

lib/dashboard-path-response.ts

@@ -0,0 +1,16 @@
+import {z} from "zod"
+import {dashboardServersSchema} from "@/lib/dashboard-readers"
+import {greResponseSchema} from "@/lib/gre-response"
+import {filtersResponseSchema} from "@/lib/filters-response"
+import {optimizerProbesSchema,optimizerRulesSchema} from "@/lib/route-optimizer-response"
+const route=z.object({gateway:z.string().nullable(),routingMark:z.string().nullable()})
+export const dashboardWanRuntimeSchema=z.object({defaultGateway:z.string().nullable(),defaultInterface:z.string().nullable(),uplinks:z.array(z.object({id:z.string().min(1),iface:z.string(),name:z.string(),isp:z.string(),configuredIp:z.string(),leasedIp:z.string().nullable(),dhcpStatus:z.string().nullable(),isDefault:z.boolean()})).refine(rows=>new Set(rows.map(r=>r.id)).size===rows.length)})
+const snapshot=z.object({sampledAt:z.iso.datetime({offset:true}),servers:dashboardServersSchema,greTunnels:greResponseSchema.shape.tunnels,filtersRulesets:filtersResponseSchema.shape.rulesets,speedProbes:optimizerProbesSchema.shape.probes,routeLookupByServerId:z.record(z.string(),route.nullable()),wanRuntimeByHomeId:z.record(z.string(),dashboardWanRuntimeSchema.nullable())}).refine(data=>{
+ const ids=new Set(data.servers.map(s=>String(s.id))),homes=data.servers.filter(s=>s.enabled&&s.type==="home-router")
+ return data.greTunnels.every(t=>ids.has(t.serverId))&&data.filtersRulesets.every(r=>ids.has(r.serverId))&&data.speedProbes.every(p=>ids.has(p.srcServerId)&&ids.has(p.dstServerId))&&Object.keys(data.routeLookupByServerId).every(id=>ids.has(id))&&Object.keys(data.wanRuntimeByHomeId).every(id=>ids.has(id))&&homes.every(h=>data.routeLookupByServerId[String(h.id)]!=null&&data.wanRuntimeByHomeId[String(h.id)]!=null)
+})
+const response=z.object({snapshot:snapshot.nullable(),sampledAt:z.iso.datetime({offset:true}).optional()}).refine(data=>data.snapshot===null?data.sampledAt===undefined:!data.sampledAt||Date.parse(data.sampledAt)===Date.parse(data.snapshot.sampledAt))
+export function parseDashboardPath(raw:unknown){const parsed=response.safeParse(raw);if(!parsed.success)throw Error("Снимок Internet path не подтверждён: данные неполны или повреждены");return parsed.data}
+export function parseDashboardFilters(raw:unknown){const parsed=optimizerRulesSchema.safeParse(raw);if(!parsed.success||parsed.data.error)throw Error("Данные Filters для Internet path не подтверждены");return parsed.data}
+export function parseDashboardSpeedProbes(raw:unknown){const parsed=optimizerProbesSchema.safeParse(raw);if(!parsed.success)throw Error("Данные проб скорости для Internet path не подтверждены");return parsed.data}
+export function parseDashboardWanRuntime(raw:unknown){const parsed=dashboardWanRuntimeSchema.safeParse(raw);if(!parsed.success)throw Error("Данные WAN для Internet path не подтверждены");return parsed.data}

lib/dashboard-readers.ts

@@ -1,7 +1,7 @@
 import {z} from "zod"
 import {serverReadSchema} from "@mmapp/contracts/servers"
 const server=serverReadSchema.pick({id:true,name:true,host:true,site:true,country:true,asn:true,type:true,enabled:true,status:true,latency:true,os:true,model:true}).extend({id:z.number().int().positive(),host:z.string().trim().min(1),latency:z.number().finite().nonnegative().nullable(),sessions:z.number().int().nonnegative(),wanUplinks:serverReadSchema.shape.wanUplinks.optional()})
-const servers=z.array(server).refine(rows=>new Set(rows.map(r=>r.id)).size===rows.length)
+export const dashboardServersSchema=z.array(server).refine(rows=>new Set(rows.map(r=>r.id)).size===rows.length)
 export {parseDashboardProbes} from "@/lib/dashboard-probes"
 export type DashboardServerRow=z.infer<typeof server>
-export function parseDashboardServers(raw:unknown){const parsed=servers.safeParse(raw);if(!parsed.success)throw Error("Некорректный каталог серверов");return parsed.data}
+export function parseDashboardServers(raw:unknown){const parsed=dashboardServersSchema.safeParse(raw);if(!parsed.success)throw Error("Некорректный каталог серверов");return parsed.data}