From 2e576984be3b3c3f525ca24ade90308f74ca6d93 Mon Sep 17 00:00:00 2001
From: Ahreum02 <126854208+Ahreum02@users.noreply.github.com>
Date: Sun, 3 May 2026 11:42:23 +0900
Subject: [PATCH 1/2] =?UTF-8?q?feat:=20=EC=8A=A4=EC=BA=94=20=EB=82=B4?=
 =?UTF-8?q?=EC=97=AD=20=ED=81=B4=EB=A6=AD=20=EC=8B=9C=20=EC=83=81=EC=84=B8?=
 =?UTF-8?q?=20=EB=B3=B4=EA=B3=A0=EC=84=9C=20=ED=8E=98=EC=9D=B4=EC=A7=80=20?=
 =?UTF-8?q?=EC=97=B0=EA=B2=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/pages/Loading/hooks/useLoadingPage.ts     | 13 ++++--
 src/pages/QRScan/hooks/useQRScanPage.ts       | 25 ++++++++---
 src/pages/ScanList/ScanListPage.tsx           | 26 +++++------
 .../scan-session/scanClassification.test.ts   | 26 +++++++++++
 .../lib/scan-session/scanClassification.ts    | 43 +++++++++++++++++++
 src/shared/store/scanSessionStore.test.ts     | 16 +++++++
 src/shared/store/scanSessionStore.ts          | 28 ++++++++----
 7 files changed, 143 insertions(+), 34 deletions(-)
 create mode 100644 src/shared/lib/scan-session/scanClassification.test.ts
 create mode 100644 src/shared/lib/scan-session/scanClassification.ts

diff --git a/src/pages/Loading/hooks/useLoadingPage.ts b/src/pages/Loading/hooks/useLoadingPage.ts
index df02e41..aab3336 100644
--- a/src/pages/Loading/hooks/useLoadingPage.ts
+++ b/src/pages/Loading/hooks/useLoadingPage.ts
@@ -7,6 +7,7 @@ import { pickString } from '@/shared/api/responseAccess/payloadAccess';
 import { resolveResultToneFromSources } from '@/shared/api/risk/resolveResultTone';
 import { mapSseStepId } from '@/shared/api/sse/sseStepMapper';
 import { ensureScanDetail } from '@/shared/lib/scan-session/ensureScanDetail';
+import { isWebScanTarget } from '@/shared/lib/scan-session/scanClassification';
 import { useScanSubscription } from '@/shared/lib/sse/useScanSubscription';
 import { useGuestStore } from '@/shared/store/guestStore';
 import { useScanProgressStore } from '@/shared/store/scanProgressStore';
@@ -32,10 +33,14 @@ const DEFAULT_LOADING_PAGE_DATA: LoadingPageData = {
 
 function openResultRouteForCurrentSession() {
   const session = getScanSessionSnapshot();
+  const currentTargetUrl = session.decodedUrl ?? session.historySelection?.url ?? null;
 
   if (
-    session.isUrl === false ||
-    (session.schemeType && session.schemeType.trim().toUpperCase() !== 'WEB')
+    !isWebScanTarget({
+      isUrl: session.isUrl,
+      schemeType: session.schemeType,
+      url: currentTargetUrl,
+    })
   ) {
     window.location.assign('/result/non-url');
     return;
@@ -53,8 +58,8 @@ function openResultRouteForCurrentSession() {
   } as const;
   const route = routeByRiskLevel[riskLevel];
 
-  if (session.decodedUrl) {
-    window.location.assign(`${route}?url=${encodeURIComponent(session.decodedUrl)}`);
+  if (currentTargetUrl) {
+    window.location.assign(`${route}?url=${encodeURIComponent(currentTargetUrl)}`);
     return;
   }
 
diff --git a/src/pages/QRScan/hooks/useQRScanPage.ts b/src/pages/QRScan/hooks/useQRScanPage.ts
index 21bc14f..2018025 100644
--- a/src/pages/QRScan/hooks/useQRScanPage.ts
+++ b/src/pages/QRScan/hooks/useQRScanPage.ts
@@ -5,6 +5,7 @@ import { App } from 'antd';
 import { useCallback, useEffect, useRef, useState } from 'react';
 
 import { showApiError } from '@/shared/lib/feedback/showApiError';
+import { isWebScanTarget } from '@/shared/lib/scan-session/scanClassification';
 import { useScanProgressStore } from '@/shared/store/scanProgressStore';
 import { useScanSessionStore } from '@/shared/store/scanSessionStore';
 
@@ -141,18 +142,30 @@ function isNonWebScanResponse(scanResponse: Record<string, unknown>): boolean {
     typeof scanResponse.schemeType === 'string'
       ? scanResponse.schemeType
       : scanResponse.scheme_type;
+  const targetValue =
+    typeof scanResponse.typeInfo === 'string'
+      ? scanResponse.typeInfo
+      : typeof scanResponse.type_info === 'string'
+        ? scanResponse.type_info
+        : typeof scanResponse.decodedUrl === 'string'
+          ? scanResponse.decodedUrl
+          : typeof scanResponse.decoded_url === 'string'
+            ? scanResponse.decoded_url
+            : typeof scanResponse.url === 'string'
+              ? scanResponse.url
+              : null;
   const schemeType = typeof rawSchemeType === 'string' ? rawSchemeType.trim().toUpperCase() : '';
   const rawIsUrl = scanResponse.isUrl !== undefined ? scanResponse.isUrl : scanResponse.is_url;
 
-  if (typeof rawIsUrl === 'boolean') {
-    return rawIsUrl === false;
-  }
-
-  return schemeType.length > 0 && schemeType !== 'WEB';
+  return !isWebScanTarget({
+    isUrl: typeof rawIsUrl === 'boolean' ? rawIsUrl : null,
+    schemeType,
+    url: targetValue,
+  });
 }
 
 function isWebHistoryItem(item: ScanHistoryItem): boolean {
-  return item.isUrl !== false && item.schemeType?.trim().toUpperCase() === 'WEB';
+  return isWebScanTarget(item);
 }
 
 function openResultPage(route: ResultRoute, url: string) {
diff --git a/src/pages/ScanList/ScanListPage.tsx b/src/pages/ScanList/ScanListPage.tsx
index b5309ac..505141f 100644
--- a/src/pages/ScanList/ScanListPage.tsx
+++ b/src/pages/ScanList/ScanListPage.tsx
@@ -1,6 +1,7 @@
 import { Link } from '@tanstack/react-router';
 
 import { qrIconByTone } from '@/shared/icon/resultIcons';
+import { isWebScanTarget } from '@/shared/lib/scan-session/scanClassification';
 import AppHeader from '@/shared/ui/app-header';
 
 import { useScanListPage } from './hooks/useScanListPage';
@@ -8,15 +9,8 @@ import * as styles from './styles/scanListPage.css';
 
 import type { ScanListStatus } from './types/scanListPage.types';
 
-type ResultRoute = '/result/critical' | '/result/non-url' | '/result/safe' | '/result/warning';
-
 const nonUrlResultRoute = '/result/non-url';
-
-const resultRouteByStatus: Record<ScanListStatus, ResultRoute> = {
-  safe: '/result/safe',
-  warning: '/result/warning',
-  critical: '/result/critical',
-};
+const reportRoute = '/report';
 
 const statusLabelByTone: Record<ScanListStatus, string> = {
   safe: '안전',
@@ -91,8 +85,12 @@ function StatusBadgeIcon({ tone }: { tone: ScanListStatus }) {
   );
 }
 
-function isWebScanListItem(item: { isUrl: boolean | null; schemeType: string | null }): boolean {
-  return item.isUrl !== false && item.schemeType?.trim().toUpperCase() === 'WEB';
+function isWebScanListItem(item: {
+  isUrl: boolean | null;
+  schemeType: string | null;
+  url: string;
+}): boolean {
+  return isWebScanTarget(item);
 }
 
 export default function ScanListPage() {
@@ -115,9 +113,7 @@ export default function ScanListPage() {
           ) : (
             <ul className={styles.list}>
               {scanListPageData.items.map((item) => {
-                const resultRoute = isWebScanListItem(item)
-                  ? resultRouteByStatus[item.status]
-                  : nonUrlResultRoute;
+                const nextRoute = isWebScanListItem(item) ? reportRoute : nonUrlResultRoute;
 
                 return (
                   <li key={item.id}>
@@ -126,8 +122,8 @@ export default function ScanListPage() {
                       onClick={() => {
                         handleSelectScanResult(item);
                       }}
-                      search={resultRoute === nonUrlResultRoute ? {} : { url: item.url }}
-                      to={resultRoute}
+                      search={nextRoute === reportRoute ? { url: item.url } : {}}
+                      to={nextRoute}
                     >
                       <span className={`${styles.badge} ${styles.badgeTone[item.status]}`}>
                         <span aria-hidden="true" className={styles.badgeIcon}>
diff --git a/src/shared/lib/scan-session/scanClassification.test.ts b/src/shared/lib/scan-session/scanClassification.test.ts
new file mode 100644
index 0000000..24310e3
--- /dev/null
+++ b/src/shared/lib/scan-session/scanClassification.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+
+import { isHttpUrl, isWebScanTarget, normalizeScanSchemeTypeAlias } from './scanClassification';
+
+describe('scanClassification', () => {
+  it('normalizes URL scheme aliases to WEB', () => {
+    expect(normalizeScanSchemeTypeAlias('URL')).toBe('WEB');
+    expect(normalizeScanSchemeTypeAlias(' web ')).toBe('WEB');
+  });
+
+  it('detects http and https targets as web URLs', () => {
+    expect(isHttpUrl('https://example.com')).toBe(true);
+    expect(isHttpUrl('http://example.com')).toBe(true);
+    expect(isHttpUrl('sms:01012345678')).toBe(false);
+  });
+
+  it('treats history items with URL scheme aliases as web scans', () => {
+    expect(
+      isWebScanTarget({
+        isUrl: false,
+        schemeType: 'URL',
+        url: 'https://example.com/path',
+      }),
+    ).toBe(true);
+  });
+});
diff --git a/src/shared/lib/scan-session/scanClassification.ts b/src/shared/lib/scan-session/scanClassification.ts
new file mode 100644
index 0000000..9de90d1
--- /dev/null
+++ b/src/shared/lib/scan-session/scanClassification.ts
@@ -0,0 +1,43 @@
+type ScanTargetLike = {
+  isUrl?: boolean | null;
+  schemeType?: string | null;
+  url?: string | null;
+};
+
+const webSchemeTypeAliases = new Set(['URL', 'WEB']);
+
+export function normalizeScanSchemeTypeAlias(schemeType: string | null): string | null {
+  if (!schemeType) {
+    return null;
+  }
+
+  const normalizedSchemeType = schemeType.trim().toUpperCase();
+
+  if (normalizedSchemeType.length === 0) {
+    return null;
+  }
+
+  return webSchemeTypeAliases.has(normalizedSchemeType) ? 'WEB' : normalizedSchemeType;
+}
+
+export function isHttpUrl(url: string | null | undefined): boolean {
+  return typeof url === 'string' && /^https?:\/\//iu.test(url.trim());
+}
+
+export function isWebScanTarget({ isUrl, schemeType, url }: ScanTargetLike): boolean {
+  const normalizedSchemeType = normalizeScanSchemeTypeAlias(schemeType ?? null);
+
+  if (normalizedSchemeType) {
+    return normalizedSchemeType === 'WEB';
+  }
+
+  if (isHttpUrl(url)) {
+    return true;
+  }
+
+  if (typeof isUrl === 'boolean') {
+    return isUrl;
+  }
+
+  return false;
+}
diff --git a/src/shared/store/scanSessionStore.test.ts b/src/shared/store/scanSessionStore.test.ts
index e736137..a23fa62 100644
--- a/src/shared/store/scanSessionStore.test.ts
+++ b/src/shared/store/scanSessionStore.test.ts
@@ -50,4 +50,20 @@ describe('scanSessionStore', () => {
     expect(state.schemeType).toBe('SMS');
     expect(state.isUrl).toBe(false);
   });
+
+  it('normalizes URL history selections as web scans', () => {
+    useScanSessionStore.getState().setHistorySelection({
+      isUrl: false,
+      riskLevel: 'safe',
+      scannedAt: '2026.05.03',
+      schemeType: 'URL',
+      url: 'https://example.com/history',
+    });
+
+    const state = useScanSessionStore.getState();
+
+    expect(state.decodedUrl).toBe('https://example.com/history');
+    expect(state.schemeType).toBe('WEB');
+    expect(state.isUrl).toBe(true);
+  });
 });
diff --git a/src/shared/store/scanSessionStore.ts b/src/shared/store/scanSessionStore.ts
index e10e2c5..d897962 100644
--- a/src/shared/store/scanSessionStore.ts
+++ b/src/shared/store/scanSessionStore.ts
@@ -8,6 +8,10 @@ import type {
   BackendScanResponse,
   BackendSseFinalPayload,
 } from '@/shared/api/types';
+import {
+  isHttpUrl,
+  normalizeScanSchemeTypeAlias,
+} from '@/shared/lib/scan-session/scanClassification';
 import type { ResultTone } from '@/shared/types/resultTone';
 
 export type ScanHistorySelection = {
@@ -85,7 +89,10 @@ function mergePersistedLightSession(
     historySelection: persisted.historySelection ?? null,
     isUrl: typeof persisted.isUrl === 'boolean' ? persisted.isUrl : null,
     riskLevel: persisted.riskLevel ?? null,
-    schemeType: typeof persisted.schemeType === 'string' ? persisted.schemeType : null,
+    schemeType:
+      typeof persisted.schemeType === 'string'
+        ? normalizeScanSchemeTypeAlias(persisted.schemeType)
+        : null,
   };
 }
 
@@ -108,7 +115,9 @@ function resolveDecodedUrl(source: unknown): string | null {
 }
 
 function resolveSchemeType(source: unknown, decodedUrl: string | null): string | null {
-  const explicitSchemeType = pickString(source, ['schemeType', 'scheme_type']);
+  const explicitSchemeType = normalizeScanSchemeTypeAlias(
+    pickString(source, ['schemeType', 'scheme_type']),
+  );
 
   if (explicitSchemeType) {
     return explicitSchemeType;
@@ -118,7 +127,7 @@ function resolveSchemeType(source: unknown, decodedUrl: string | null): string |
     return null;
   }
 
-  if (/^https?:\/\//iu.test(decodedUrl)) {
+  if (isHttpUrl(decodedUrl)) {
     return 'WEB';
   }
 
@@ -131,17 +140,18 @@ function resolveIsUrl(
   schemeType: string | null,
 ): boolean | null {
   const explicitIsUrl = pickBoolean(source, ['isUrl', 'is_url']);
+  const normalizedSchemeType = normalizeScanSchemeTypeAlias(schemeType);
 
-  if (explicitIsUrl !== null) {
-    return explicitIsUrl;
+  if (normalizedSchemeType) {
+    return normalizedSchemeType === 'WEB';
   }
 
-  if (schemeType) {
-    return schemeType.trim().toUpperCase() === 'WEB';
+  if (isHttpUrl(decodedUrl)) {
+    return true;
   }
 
-  if (decodedUrl) {
-    return /^https?:\/\//iu.test(decodedUrl);
+  if (explicitIsUrl !== null) {
+    return explicitIsUrl;
   }
 
   return null;

From 5f48bba646198048c04f5ad84347873546985656 Mon Sep 17 00:00:00 2001
From: Ahreum02 <126854208+Ahreum02@users.noreply.github.com>
Date: Sun, 3 May 2026 12:00:26 +0900
Subject: [PATCH 2/2] =?UTF-8?q?refactor:=20scan=20scheme=20=EC=B2=98?=
 =?UTF-8?q?=EB=A6=AC=20=EB=A1=9C=EC=A7=81=20=EA=B0=9C=EC=84=A0=20=EB=B0=8F?=
 =?UTF-8?q?=20edge-case=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=B6=94=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/pages/QRScan/hooks/useQRScanPage.ts       |   3 +-
 src/pages/ScanList/ScanListPage.tsx           |  10 +-
 .../scan-session/scanClassification.test.ts   | 104 +++++++++++++++---
 .../lib/scan-session/scanClassification.ts    |   6 +-
 src/shared/store/scanSessionStore.ts          |   5 +-
 5 files changed, 96 insertions(+), 32 deletions(-)

diff --git a/src/pages/QRScan/hooks/useQRScanPage.ts b/src/pages/QRScan/hooks/useQRScanPage.ts
index 2018025..a5b2173 100644
--- a/src/pages/QRScan/hooks/useQRScanPage.ts
+++ b/src/pages/QRScan/hooks/useQRScanPage.ts
@@ -154,12 +154,11 @@ function isNonWebScanResponse(scanResponse: Record<string, unknown>): boolean {
             : typeof scanResponse.url === 'string'
               ? scanResponse.url
               : null;
-  const schemeType = typeof rawSchemeType === 'string' ? rawSchemeType.trim().toUpperCase() : '';
   const rawIsUrl = scanResponse.isUrl !== undefined ? scanResponse.isUrl : scanResponse.is_url;
 
   return !isWebScanTarget({
     isUrl: typeof rawIsUrl === 'boolean' ? rawIsUrl : null,
-    schemeType,
+    schemeType: typeof rawSchemeType === 'string' ? rawSchemeType : null,
     url: targetValue,
   });
 }
diff --git a/src/pages/ScanList/ScanListPage.tsx b/src/pages/ScanList/ScanListPage.tsx
index 505141f..33f3261 100644
--- a/src/pages/ScanList/ScanListPage.tsx
+++ b/src/pages/ScanList/ScanListPage.tsx
@@ -85,14 +85,6 @@ function StatusBadgeIcon({ tone }: { tone: ScanListStatus }) {
   );
 }
 
-function isWebScanListItem(item: {
-  isUrl: boolean | null;
-  schemeType: string | null;
-  url: string;
-}): boolean {
-  return isWebScanTarget(item);
-}
-
 export default function ScanListPage() {
   const { handleSelectScanResult, scanListPageData, scanListUuid } = useScanListPage();
 
@@ -113,7 +105,7 @@ export default function ScanListPage() {
           ) : (
             <ul className={styles.list}>
               {scanListPageData.items.map((item) => {
-                const nextRoute = isWebScanListItem(item) ? reportRoute : nonUrlResultRoute;
+                const nextRoute = isWebScanTarget(item) ? reportRoute : nonUrlResultRoute;
 
                 return (
                   <li key={item.id}>
diff --git a/src/shared/lib/scan-session/scanClassification.test.ts b/src/shared/lib/scan-session/scanClassification.test.ts
index 24310e3..9f05f4d 100644
--- a/src/shared/lib/scan-session/scanClassification.test.ts
+++ b/src/shared/lib/scan-session/scanClassification.test.ts
@@ -3,24 +3,98 @@ import { describe, expect, it } from 'vitest';
 import { isHttpUrl, isWebScanTarget, normalizeScanSchemeTypeAlias } from './scanClassification';
 
 describe('scanClassification', () => {
-  it('normalizes URL scheme aliases to WEB', () => {
-    expect(normalizeScanSchemeTypeAlias('URL')).toBe('WEB');
-    expect(normalizeScanSchemeTypeAlias(' web ')).toBe('WEB');
+  describe('normalizeScanSchemeTypeAlias', () => {
+    it('returns null for missing and empty scheme values', () => {
+      expect(normalizeScanSchemeTypeAlias(null)).toBeNull();
+      expect(normalizeScanSchemeTypeAlias(undefined)).toBeNull();
+      expect(normalizeScanSchemeTypeAlias('')).toBeNull();
+      expect(normalizeScanSchemeTypeAlias('   ')).toBeNull();
+    });
+
+    it('normalizes known web scheme aliases regardless of casing and whitespace', () => {
+      expect(normalizeScanSchemeTypeAlias('URL')).toBe('WEB');
+      expect(normalizeScanSchemeTypeAlias(' Url ')).toBe('WEB');
+      expect(normalizeScanSchemeTypeAlias(' web ')).toBe('WEB');
+    });
+
+    it('preserves unknown schemes after normalization', () => {
+      expect(normalizeScanSchemeTypeAlias('sms')).toBe('SMS');
+      expect(normalizeScanSchemeTypeAlias(' ftp ')).toBe('FTP');
+    });
   });
 
-  it('detects http and https targets as web URLs', () => {
-    expect(isHttpUrl('https://example.com')).toBe(true);
-    expect(isHttpUrl('http://example.com')).toBe(true);
-    expect(isHttpUrl('sms:01012345678')).toBe(false);
+  describe('isHttpUrl', () => {
+    it('accepts http and https URLs across casing and surrounding whitespace', () => {
+      expect(isHttpUrl('https://example.com')).toBe(true);
+      expect(isHttpUrl(' HTTP://example.com/path ')).toBe(true);
+      expect(isHttpUrl('HtTpS://example.com')).toBe(true);
+    });
+
+    it('rejects non-string inputs and non-http schemes', () => {
+      expect(isHttpUrl(null)).toBe(false);
+      expect(isHttpUrl(undefined)).toBe(false);
+      expect(isHttpUrl(42)).toBe(false);
+      expect(isHttpUrl('ftp://example.com')).toBe(false);
+      expect(isHttpUrl('mailto:help@example.com')).toBe(false);
+    });
   });
 
-  it('treats history items with URL scheme aliases as web scans', () => {
-    expect(
-      isWebScanTarget({
-        isUrl: false,
-        schemeType: 'URL',
-        url: 'https://example.com/path',
-      }),
-    ).toBe(true);
+  describe('isWebScanTarget', () => {
+    it('treats URL scheme aliases as web scans even when isUrl is false', () => {
+      expect(
+        isWebScanTarget({
+          isUrl: false,
+          schemeType: 'URL',
+          url: 'https://example.com/path',
+        }),
+      ).toBe(true);
+    });
+
+    it('normalizes scheme casing and whitespace before classification', () => {
+      expect(
+        isWebScanTarget({
+          isUrl: null,
+          schemeType: ' web ',
+          url: '',
+        }),
+      ).toBe(true);
+    });
+
+    it('falls back to the URL when the scheme is null', () => {
+      expect(
+        isWebScanTarget({
+          isUrl: null,
+          schemeType: null,
+          url: 'https://example.com/fallback',
+        }),
+      ).toBe(true);
+    });
+
+    it('prefers an explicit true isUrl flag when scheme and URL are missing', () => {
+      expect(
+        isWebScanTarget({
+          isUrl: true,
+          schemeType: null,
+          url: '',
+        }),
+      ).toBe(true);
+    });
+
+    it('rejects unknown schemes with empty or invalid URLs', () => {
+      expect(
+        isWebScanTarget({
+          isUrl: null,
+          schemeType: 'sms',
+          url: '',
+        }),
+      ).toBe(false);
+      expect(
+        isWebScanTarget({
+          isUrl: null,
+          schemeType: null,
+          url: 'mailto:help@example.com',
+        }),
+      ).toBe(false);
+    });
   });
 });
diff --git a/src/shared/lib/scan-session/scanClassification.ts b/src/shared/lib/scan-session/scanClassification.ts
index 9de90d1..80fa64e 100644
--- a/src/shared/lib/scan-session/scanClassification.ts
+++ b/src/shared/lib/scan-session/scanClassification.ts
@@ -6,7 +6,7 @@ type ScanTargetLike = {
 
 const webSchemeTypeAliases = new Set(['URL', 'WEB']);
 
-export function normalizeScanSchemeTypeAlias(schemeType: string | null): string | null {
+export function normalizeScanSchemeTypeAlias(schemeType: string | null | undefined): string | null {
   if (!schemeType) {
     return null;
   }
@@ -20,12 +20,12 @@ export function normalizeScanSchemeTypeAlias(schemeType: string | null): string
   return webSchemeTypeAliases.has(normalizedSchemeType) ? 'WEB' : normalizedSchemeType;
 }
 
-export function isHttpUrl(url: string | null | undefined): boolean {
+export function isHttpUrl(url: unknown): boolean {
   return typeof url === 'string' && /^https?:\/\//iu.test(url.trim());
 }
 
 export function isWebScanTarget({ isUrl, schemeType, url }: ScanTargetLike): boolean {
-  const normalizedSchemeType = normalizeScanSchemeTypeAlias(schemeType ?? null);
+  const normalizedSchemeType = normalizeScanSchemeTypeAlias(schemeType);
 
   if (normalizedSchemeType) {
     return normalizedSchemeType === 'WEB';
diff --git a/src/shared/store/scanSessionStore.ts b/src/shared/store/scanSessionStore.ts
index d897962..11adb0d 100644
--- a/src/shared/store/scanSessionStore.ts
+++ b/src/shared/store/scanSessionStore.ts
@@ -140,10 +140,9 @@ function resolveIsUrl(
   schemeType: string | null,
 ): boolean | null {
   const explicitIsUrl = pickBoolean(source, ['isUrl', 'is_url']);
-  const normalizedSchemeType = normalizeScanSchemeTypeAlias(schemeType);
 
-  if (normalizedSchemeType) {
-    return normalizedSchemeType === 'WEB';
+  if (schemeType) {
+    return schemeType === 'WEB';
   }
 
   if (isHttpUrl(decodedUrl)) {