diff --git a/frontend/src/pages/inbounds/InboundFormModal.tsx b/frontend/src/pages/inbounds/InboundFormModal.tsx
index 689ba50b..5227f134 100644
--- a/frontend/src/pages/inbounds/InboundFormModal.tsx
+++ b/frontend/src/pages/inbounds/InboundFormModal.tsx
@@ -1446,13 +1446,13 @@ export default function InboundFormModal({
   // the Select shows blank instead of the "Default (path)" option.
   const newStreamSlice = (n: string): Record<string, unknown> => {
     switch (n) {
-      case 'tcp':         return TcpStreamSettingsSchema.parse({ header: { type: 'none' } });
-      case 'kcp':         return KcpStreamSettingsSchema.parse({});
-      case 'ws':          return WsStreamSettingsSchema.parse({});
-      case 'grpc':        return GrpcStreamSettingsSchema.parse({});
+      case 'tcp': return TcpStreamSettingsSchema.parse({ header: { type: 'none' } });
+      case 'kcp': return KcpStreamSettingsSchema.parse({});
+      case 'ws': return WsStreamSettingsSchema.parse({});
+      case 'grpc': return GrpcStreamSettingsSchema.parse({});
       case 'httpupgrade': return HttpUpgradeStreamSettingsSchema.parse({});
-      case 'xhttp':       return XHttpStreamSettingsSchema.parse({});
-      default:            return {};
+      case 'xhttp': return XHttpStreamSettingsSchema.parse({});
+      default: return {};
     }
   };
   const onNetworkChange = (next: string) => {
@@ -1474,7 +1474,7 @@ export default function InboundFormModal({
             style={{ width: '75%' }}
             onChange={onNetworkChange}
             options={[
-              { value: 'tcp', label: 'TCP (RAW)' },
+              { value: 'tcp', label: 'RAW' },
               { value: 'kcp', label: 'mKCP' },
               { value: 'ws', label: 'WebSocket' },
               { value: 'grpc', label: 'gRPC' },
@@ -1521,10 +1521,10 @@ export default function InboundFormModal({
                         ['streamSettings', 'hysteriaSettings', 'masquerade'],
                         checked
                           ? {
-                              type: '', dir: '', url: '',
-                              rewriteHost: false, insecure: false,
-                              content: '', headers: {}, statusCode: 0,
-                            }
+                            type: '', dir: '', url: '',
+                            rewriteHost: false, insecure: false,
+                            content: '', headers: {}, statusCode: 0,
+                          }
                           : undefined,
                       )
                     }
@@ -1644,20 +1644,20 @@ export default function InboundFormModal({
                         ['streamSettings', 'tcpSettings', 'header'],
                         v
                           ? {
-                              type: 'http',
-                              request: {
-                                version: '1.1',
-                                method: 'GET',
-                                path: ['/'],
-                                headers: {},
-                              },
-                              response: {
-                                version: '1.1',
-                                status: '200',
-                                reason: 'OK',
-                                headers: {},
-                              },
-                            }
+                            type: 'http',
+                            request: {
+                              version: '1.1',
+                              method: 'GET',
+                              path: ['/'],
+                              headers: {},
+                            },
+                            response: {
+                              version: '1.1',
+                              status: '200',
+                              reason: 'OK',
+                              headers: {},
+                            },
+                          }
                           : { type: 'none' },
                       );
                     }}
@@ -2181,233 +2181,233 @@ export default function InboundFormModal({
               </Form.Item>
               {on && (
                 <>
-          <Form.Item name={['streamSettings', 'sockopt', 'mark']} label="Route Mark">
-            <InputNumber min={0} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'tcpKeepAliveInterval']}
-            label="TCP Keep Alive Interval"
-          >
-            <InputNumber min={0} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'tcpKeepAliveIdle']}
-            label="TCP Keep Alive Idle"
-          >
-            <InputNumber min={0} />
-          </Form.Item>
-          <Form.Item name={['streamSettings', 'sockopt', 'tcpMaxSeg']} label="TCP Max Seg">
-            <InputNumber min={0} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'tcpUserTimeout']}
-            label="TCP User Timeout"
-          >
-            <InputNumber min={0} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'tcpWindowClamp']}
-            label="TCP Window Clamp"
-          >
-            <InputNumber min={0} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'acceptProxyProtocol']}
-            label="Proxy Protocol"
-            valuePropName="checked"
-          >
-            <Switch />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'tcpFastOpen']}
-            label="TCP Fast Open"
-            valuePropName="checked"
-          >
-            <Switch />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'tcpMptcp']}
-            label="Multipath TCP"
-            valuePropName="checked"
-          >
-            <Switch />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'penetrate']}
-            label="Penetrate"
-            valuePropName="checked"
-          >
-            <Switch />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'V6Only']}
-            label="V6 Only"
-            valuePropName="checked"
-          >
-            <Switch />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'domainStrategy']}
-            label="Domain Strategy"
-          >
-            <Select
-              style={{ width: '50%' }}
-              options={Object.values(DOMAIN_STRATEGY_OPTION).map((d) => ({ value: d, label: d }))}
-            />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'tcpcongestion']}
-            label="TCP Congestion"
-          >
-            <Select
-              style={{ width: '50%' }}
-              options={Object.values(TCP_CONGESTION_OPTION).map((c) => ({ value: c, label: c }))}
-            />
-          </Form.Item>
-          <Form.Item name={['streamSettings', 'sockopt', 'tproxy']} label="TProxy">
-            <Select
-              style={{ width: '50%' }}
-              options={[
-                { value: 'off', label: 'Off' },
-                { value: 'redirect', label: 'Redirect' },
-                { value: 'tproxy', label: 'TProxy' },
-              ]}
-            />
-          </Form.Item>
-          <Form.Item name={['streamSettings', 'sockopt', 'dialerProxy']} label="Dialer Proxy">
-            <Input />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'interfaceName']}
-            label="Interface Name"
-          >
-            <Input />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'trustedXForwardedFor']}
-            label="Trusted X-Forwarded-For"
-          >
-            <Select
-              mode="tags"
-              style={{ width: '100%' }}
-              tokenSeparators={[',']}
-              options={[
-                { value: 'CF-Connecting-IP', label: 'CF-Connecting-IP' },
-                { value: 'X-Real-IP', label: 'X-Real-IP' },
-                { value: 'True-Client-IP', label: 'True-Client-IP' },
-                { value: 'X-Client-IP', label: 'X-Client-IP' },
-              ]}
-            />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'sockopt', 'addressPortStrategy']}
-            label="Address+port strategy"
-          >
-            <Select
-              style={{ width: '50%' }}
-              options={Object.values(Address_Port_Strategy).map((v) => ({ value: v, label: v }))}
-            />
-          </Form.Item>
-          <Form.Item shouldUpdate noStyle>
-            {({ getFieldValue, setFieldValue }) => {
-              const he = getFieldValue(['streamSettings', 'sockopt', 'happyEyeballs']);
-              const hasHe = he != null;
-              return (
-                <>
-                  <Form.Item label="Happy Eyeballs">
-                    <Switch
-                      checked={hasHe}
-                      onChange={(v) => {
-                        setFieldValue(
-                          ['streamSettings', 'sockopt', 'happyEyeballs'],
-                          v ? HappyEyeballsSchema.parse({}) : undefined,
-                        );
-                      }}
+                  <Form.Item name={['streamSettings', 'sockopt', 'mark']} label="Route Mark">
+                    <InputNumber min={0} />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'tcpKeepAliveInterval']}
+                    label="TCP Keep Alive Interval"
+                  >
+                    <InputNumber min={0} />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'tcpKeepAliveIdle']}
+                    label="TCP Keep Alive Idle"
+                  >
+                    <InputNumber min={0} />
+                  </Form.Item>
+                  <Form.Item name={['streamSettings', 'sockopt', 'tcpMaxSeg']} label="TCP Max Seg">
+                    <InputNumber min={0} />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'tcpUserTimeout']}
+                    label="TCP User Timeout"
+                  >
+                    <InputNumber min={0} />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'tcpWindowClamp']}
+                    label="TCP Window Clamp"
+                  >
+                    <InputNumber min={0} />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'acceptProxyProtocol']}
+                    label="Proxy Protocol"
+                    valuePropName="checked"
+                  >
+                    <Switch />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'tcpFastOpen']}
+                    label="TCP Fast Open"
+                    valuePropName="checked"
+                  >
+                    <Switch />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'tcpMptcp']}
+                    label="Multipath TCP"
+                    valuePropName="checked"
+                  >
+                    <Switch />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'penetrate']}
+                    label="Penetrate"
+                    valuePropName="checked"
+                  >
+                    <Switch />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'V6Only']}
+                    label="V6 Only"
+                    valuePropName="checked"
+                  >
+                    <Switch />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'domainStrategy']}
+                    label="Domain Strategy"
+                  >
+                    <Select
+                      style={{ width: '50%' }}
+                      options={Object.values(DOMAIN_STRATEGY_OPTION).map((d) => ({ value: d, label: d }))}
                     />
                   </Form.Item>
-                  {hasHe && (
-                    <>
-                      <Form.Item
-                        name={['streamSettings', 'sockopt', 'happyEyeballs', 'tryDelayMs']}
-                        label="Try delay (ms)"
-                      >
-                        <InputNumber min={0} placeholder="0 disabled — 250 recommended" />
-                      </Form.Item>
-                      <Form.Item
-                        name={['streamSettings', 'sockopt', 'happyEyeballs', 'prioritizeIPv6']}
-                        label="Prioritize IPv6"
-                        valuePropName="checked"
-                      >
-                        <Switch />
-                      </Form.Item>
-                      <Form.Item
-                        name={['streamSettings', 'sockopt', 'happyEyeballs', 'interleave']}
-                        label="Interleave"
-                      >
-                        <InputNumber min={1} />
-                      </Form.Item>
-                      <Form.Item
-                        name={['streamSettings', 'sockopt', 'happyEyeballs', 'maxConcurrentTry']}
-                        label="Max concurrent try"
-                      >
-                        <InputNumber min={0} />
-                      </Form.Item>
-                    </>
-                  )}
-                </>
-              );
-            }}
-          </Form.Item>
-          <Form.List name={['streamSettings', 'sockopt', 'customSockopt']}>
-            {(fields, { add, remove }) => (
-              <>
-                <Form.Item label="Custom sockopt">
-                  <Button
-                    type="dashed"
-                    size="small"
-                    onClick={() => add({ type: 'int', level: '6', opt: '', value: '' })}
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'tcpcongestion']}
+                    label="TCP Congestion"
                   >
-                    + Add custom option
-                  </Button>
-                </Form.Item>
-                {fields.map((field) => (
-                  <Space.Compact key={field.key} style={{ display: 'flex', marginBottom: 8 }}>
-                    <Form.Item name={[field.name, 'system']} noStyle>
-                      <Select
-                        placeholder="all"
-                        allowClear
-                        style={{ width: 100 }}
-                        options={[
-                          { value: 'linux', label: 'linux' },
-                          { value: 'windows', label: 'windows' },
-                          { value: 'darwin', label: 'darwin' },
-                        ]}
-                      />
-                    </Form.Item>
-                    <Form.Item name={[field.name, 'type']} noStyle>
-                      <Select
-                        style={{ width: 80 }}
-                        options={[
-                          { value: 'int', label: 'int' },
-                          { value: 'str', label: 'str' },
-                        ]}
-                      />
-                    </Form.Item>
-                    <Form.Item name={[field.name, 'level']} noStyle>
-                      <Input placeholder="level (6=TCP)" style={{ width: 100 }} />
-                    </Form.Item>
-                    <Form.Item name={[field.name, 'opt']} noStyle>
-                      <Input placeholder="opt" style={{ width: 120 }} />
-                    </Form.Item>
-                    <Form.Item name={[field.name, 'value']} noStyle>
-                      <Input placeholder="value" style={{ flex: 1 }} />
-                    </Form.Item>
-                    <Button danger onClick={() => remove(field.name)}>−</Button>
-                  </Space.Compact>
-                ))}
-              </>
-            )}
-          </Form.List>
+                    <Select
+                      style={{ width: '50%' }}
+                      options={Object.values(TCP_CONGESTION_OPTION).map((c) => ({ value: c, label: c }))}
+                    />
+                  </Form.Item>
+                  <Form.Item name={['streamSettings', 'sockopt', 'tproxy']} label="TProxy">
+                    <Select
+                      style={{ width: '50%' }}
+                      options={[
+                        { value: 'off', label: 'Off' },
+                        { value: 'redirect', label: 'Redirect' },
+                        { value: 'tproxy', label: 'TProxy' },
+                      ]}
+                    />
+                  </Form.Item>
+                  <Form.Item name={['streamSettings', 'sockopt', 'dialerProxy']} label="Dialer Proxy">
+                    <Input />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'interfaceName']}
+                    label="Interface Name"
+                  >
+                    <Input />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'trustedXForwardedFor']}
+                    label="Trusted X-Forwarded-For"
+                  >
+                    <Select
+                      mode="tags"
+                      style={{ width: '100%' }}
+                      tokenSeparators={[',']}
+                      options={[
+                        { value: 'CF-Connecting-IP', label: 'CF-Connecting-IP' },
+                        { value: 'X-Real-IP', label: 'X-Real-IP' },
+                        { value: 'True-Client-IP', label: 'True-Client-IP' },
+                        { value: 'X-Client-IP', label: 'X-Client-IP' },
+                      ]}
+                    />
+                  </Form.Item>
+                  <Form.Item
+                    name={['streamSettings', 'sockopt', 'addressPortStrategy']}
+                    label="Address+port strategy"
+                  >
+                    <Select
+                      style={{ width: '50%' }}
+                      options={Object.values(Address_Port_Strategy).map((v) => ({ value: v, label: v }))}
+                    />
+                  </Form.Item>
+                  <Form.Item shouldUpdate noStyle>
+                    {({ getFieldValue, setFieldValue }) => {
+                      const he = getFieldValue(['streamSettings', 'sockopt', 'happyEyeballs']);
+                      const hasHe = he != null;
+                      return (
+                        <>
+                          <Form.Item label="Happy Eyeballs">
+                            <Switch
+                              checked={hasHe}
+                              onChange={(v) => {
+                                setFieldValue(
+                                  ['streamSettings', 'sockopt', 'happyEyeballs'],
+                                  v ? HappyEyeballsSchema.parse({}) : undefined,
+                                );
+                              }}
+                            />
+                          </Form.Item>
+                          {hasHe && (
+                            <>
+                              <Form.Item
+                                name={['streamSettings', 'sockopt', 'happyEyeballs', 'tryDelayMs']}
+                                label="Try delay (ms)"
+                              >
+                                <InputNumber min={0} placeholder="0 disabled — 250 recommended" />
+                              </Form.Item>
+                              <Form.Item
+                                name={['streamSettings', 'sockopt', 'happyEyeballs', 'prioritizeIPv6']}
+                                label="Prioritize IPv6"
+                                valuePropName="checked"
+                              >
+                                <Switch />
+                              </Form.Item>
+                              <Form.Item
+                                name={['streamSettings', 'sockopt', 'happyEyeballs', 'interleave']}
+                                label="Interleave"
+                              >
+                                <InputNumber min={1} />
+                              </Form.Item>
+                              <Form.Item
+                                name={['streamSettings', 'sockopt', 'happyEyeballs', 'maxConcurrentTry']}
+                                label="Max concurrent try"
+                              >
+                                <InputNumber min={0} />
+                              </Form.Item>
+                            </>
+                          )}
+                        </>
+                      );
+                    }}
+                  </Form.Item>
+                  <Form.List name={['streamSettings', 'sockopt', 'customSockopt']}>
+                    {(fields, { add, remove }) => (
+                      <>
+                        <Form.Item label="Custom sockopt">
+                          <Button
+                            type="dashed"
+                            size="small"
+                            onClick={() => add({ type: 'int', level: '6', opt: '', value: '' })}
+                          >
+                            + Add custom option
+                          </Button>
+                        </Form.Item>
+                        {fields.map((field) => (
+                          <Space.Compact key={field.key} style={{ display: 'flex', marginBottom: 8 }}>
+                            <Form.Item name={[field.name, 'system']} noStyle>
+                              <Select
+                                placeholder="all"
+                                allowClear
+                                style={{ width: 100 }}
+                                options={[
+                                  { value: 'linux', label: 'linux' },
+                                  { value: 'windows', label: 'windows' },
+                                  { value: 'darwin', label: 'darwin' },
+                                ]}
+                              />
+                            </Form.Item>
+                            <Form.Item name={[field.name, 'type']} noStyle>
+                              <Select
+                                style={{ width: 80 }}
+                                options={[
+                                  { value: 'int', label: 'int' },
+                                  { value: 'str', label: 'str' },
+                                ]}
+                              />
+                            </Form.Item>
+                            <Form.Item name={[field.name, 'level']} noStyle>
+                              <Input placeholder="level (6=TCP)" style={{ width: 100 }} />
+                            </Form.Item>
+                            <Form.Item name={[field.name, 'opt']} noStyle>
+                              <Input placeholder="opt" style={{ width: 120 }} />
+                            </Form.Item>
+                            <Form.Item name={[field.name, 'value']} noStyle>
+                              <Input placeholder="value" style={{ flex: 1 }} />
+                            </Form.Item>
+                            <Button danger onClick={() => remove(field.name)}>−</Button>
+                          </Space.Compact>
+                        ))}
+                      </>
+                    )}
+                  </Form.List>
                 </>
               )}
             </>
@@ -2473,240 +2473,240 @@ export default function InboundFormModal({
           return (
             <>
               <Form.Item name={['streamSettings', 'tlsSettings', 'serverName']} label="SNI">
-            <Input placeholder="Server Name Indication" />
-          </Form.Item>
-          <Form.Item name={['streamSettings', 'tlsSettings', 'cipherSuites']} label="Cipher Suites">
-            <Select
-              options={[
-                { value: '', label: 'Auto' },
-                ...Object.entries(TLS_CIPHER_OPTION).map(([k, v]) => ({ value: v, label: k })),
-              ]}
-            />
-          </Form.Item>
-          <Form.Item label="Min/Max Version">
-            <Space.Compact block>
-              <Form.Item name={['streamSettings', 'tlsSettings', 'minVersion']} noStyle>
+                <Input placeholder="Server Name Indication" />
+              </Form.Item>
+              <Form.Item name={['streamSettings', 'tlsSettings', 'cipherSuites']} label="Cipher Suites">
                 <Select
-                  style={{ width: '50%' }}
-                  options={Object.values(TLS_VERSION_OPTION).map((v) => ({ value: v, label: v }))}
+                  options={[
+                    { value: '', label: 'Auto' },
+                    ...Object.entries(TLS_CIPHER_OPTION).map(([k, v]) => ({ value: v, label: k })),
+                  ]}
                 />
               </Form.Item>
-              <Form.Item name={['streamSettings', 'tlsSettings', 'maxVersion']} noStyle>
+              <Form.Item label="Min/Max Version">
+                <Space.Compact block>
+                  <Form.Item name={['streamSettings', 'tlsSettings', 'minVersion']} noStyle>
+                    <Select
+                      style={{ width: '50%' }}
+                      options={Object.values(TLS_VERSION_OPTION).map((v) => ({ value: v, label: v }))}
+                    />
+                  </Form.Item>
+                  <Form.Item name={['streamSettings', 'tlsSettings', 'maxVersion']} noStyle>
+                    <Select
+                      style={{ width: '50%' }}
+                      options={Object.values(TLS_VERSION_OPTION).map((v) => ({ value: v, label: v }))}
+                    />
+                  </Form.Item>
+                </Space.Compact>
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'tlsSettings', 'settings', 'fingerprint']}
+                label="uTLS"
+              >
                 <Select
-                  style={{ width: '50%' }}
-                  options={Object.values(TLS_VERSION_OPTION).map((v) => ({ value: v, label: v }))}
+                  options={[
+                    { value: '', label: 'None' },
+                    ...Object.values(UTLS_FINGERPRINT).map((fp) => ({ value: fp, label: fp })),
+                  ]}
                 />
               </Form.Item>
-            </Space.Compact>
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'tlsSettings', 'settings', 'fingerprint']}
-            label="uTLS"
-          >
-            <Select
-              options={[
-                { value: '', label: 'None' },
-                ...Object.values(UTLS_FINGERPRINT).map((fp) => ({ value: fp, label: fp })),
-              ]}
-            />
-          </Form.Item>
-          <Form.Item name={['streamSettings', 'tlsSettings', 'alpn']} label="ALPN">
-            <Select
-              mode="multiple"
-              tokenSeparators={[',']}
-              style={{ width: '100%' }}
-              options={Object.values(ALPN_OPTION).map((a) => ({ value: a, label: a }))}
-            />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'tlsSettings', 'rejectUnknownSni']}
-            label="Reject Unknown SNI"
-            valuePropName="checked"
-          >
-            <Switch />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'tlsSettings', 'disableSystemRoot']}
-            label="Disable System Root"
-            valuePropName="checked"
-          >
-            <Switch />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'tlsSettings', 'enableSessionResumption']}
-            label="Session Resumption"
-            valuePropName="checked"
-          >
-            <Switch />
-          </Form.Item>
+              <Form.Item name={['streamSettings', 'tlsSettings', 'alpn']} label="ALPN">
+                <Select
+                  mode="multiple"
+                  tokenSeparators={[',']}
+                  style={{ width: '100%' }}
+                  options={Object.values(ALPN_OPTION).map((a) => ({ value: a, label: a }))}
+                />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'tlsSettings', 'rejectUnknownSni']}
+                label="Reject Unknown SNI"
+                valuePropName="checked"
+              >
+                <Switch />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'tlsSettings', 'disableSystemRoot']}
+                label="Disable System Root"
+                valuePropName="checked"
+              >
+                <Switch />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'tlsSettings', 'enableSessionResumption']}
+                label="Session Resumption"
+                valuePropName="checked"
+              >
+                <Switch />
+              </Form.Item>
 
-          <Form.List name={['streamSettings', 'tlsSettings', 'certificates']}>
-            {(certFields, { add, remove }) => (
-              <>
-                <Form.Item label={t('certificate')}>
-                  <Button
-                    type="primary"
-                    size="small"
-                    onClick={() => add({
-                      useFile: true,
-                      certificateFile: '',
-                      keyFile: '',
-                      certificate: [],
-                      key: [],
-                      oneTimeLoading: false,
-                      usage: 'encipherment',
-                      buildChain: false,
-                    })}
-                  >
-                    <PlusOutlined />
-                  </Button>
-                </Form.Item>
-                {certFields.map((certField, idx) => (
-                  <div key={certField.key}>
-                    <Form.Item
-                      name={[certField.name, 'useFile']}
-                      label={`${t('certificate')} ${idx + 1}`}
-                    >
-                      <Radio.Group buttonStyle="solid">
-                        <Radio.Button value={true}>
-                          {t('pages.inbounds.certificatePath')}
-                        </Radio.Button>
-                        <Radio.Button value={false}>
-                          {t('pages.inbounds.certificateContent')}
-                        </Radio.Button>
-                      </Radio.Group>
+              <Form.List name={['streamSettings', 'tlsSettings', 'certificates']}>
+                {(certFields, { add, remove }) => (
+                  <>
+                    <Form.Item label={t('certificate')}>
+                      <Button
+                        type="primary"
+                        size="small"
+                        onClick={() => add({
+                          useFile: true,
+                          certificateFile: '',
+                          keyFile: '',
+                          certificate: [],
+                          key: [],
+                          oneTimeLoading: false,
+                          usage: 'encipherment',
+                          buildChain: false,
+                        })}
+                      >
+                        <PlusOutlined />
+                      </Button>
                     </Form.Item>
-                    {certFields.length > 1 && (
-                      <Form.Item label=" ">
-                        <Button
-                          size="small"
-                          danger
-                          onClick={() => remove(certField.name)}
+                    {certFields.map((certField, idx) => (
+                      <div key={certField.key}>
+                        <Form.Item
+                          name={[certField.name, 'useFile']}
+                          label={`${t('certificate')} ${idx + 1}`}
                         >
-                          <MinusOutlined /> Remove
-                        </Button>
-                      </Form.Item>
-                    )}
-                    <Form.Item
-                      noStyle
-                      shouldUpdate={(prev, curr) =>
-                        prev.streamSettings?.tlsSettings?.certificates?.[certField.name]?.useFile
-                        !== curr.streamSettings?.tlsSettings?.certificates?.[certField.name]?.useFile
-                      }
-                    >
-                      {({ getFieldValue }) => {
-                        const useFile = getFieldValue([
-                          'streamSettings', 'tlsSettings', 'certificates',
-                          certField.name, 'useFile',
-                        ]);
-                        return useFile ? (
-                          <>
-                            <Form.Item
-                              name={[certField.name, 'certificateFile']}
-                              label={t('pages.inbounds.publicKey')}
+                          <Radio.Group buttonStyle="solid">
+                            <Radio.Button value={true}>
+                              {t('pages.inbounds.certificatePath')}
+                            </Radio.Button>
+                            <Radio.Button value={false}>
+                              {t('pages.inbounds.certificateContent')}
+                            </Radio.Button>
+                          </Radio.Group>
+                        </Form.Item>
+                        {certFields.length > 1 && (
+                          <Form.Item label=" ">
+                            <Button
+                              size="small"
+                              danger
+                              onClick={() => remove(certField.name)}
                             >
-                              <Input />
-                            </Form.Item>
-                            <Form.Item
-                              name={[certField.name, 'keyFile']}
-                              label={t('pages.inbounds.privatekey')}
-                            >
-                              <Input />
-                            </Form.Item>
-                          </>
-                        ) : (
-                          <>
-                            <Form.Item
-                              name={[certField.name, 'certificate']}
-                              label={t('pages.inbounds.publicKey')}
-                              normalize={(v) => typeof v === 'string'
-                                ? v.split('\n')
-                                : v}
-                              getValueProps={(v) => ({
-                                value: Array.isArray(v) ? v.join('\n') : v,
-                              })}
-                            >
-                              <TextArea autoSize={{ minRows: 3, maxRows: 8 }} />
-                            </Form.Item>
-                            <Form.Item
-                              name={[certField.name, 'key']}
-                              label={t('pages.inbounds.privatekey')}
-                              normalize={(v) => typeof v === 'string'
-                                ? v.split('\n')
-                                : v}
-                              getValueProps={(v) => ({
-                                value: Array.isArray(v) ? v.join('\n') : v,
-                              })}
-                            >
-                              <TextArea autoSize={{ minRows: 3, maxRows: 8 }} />
-                            </Form.Item>
-                          </>
-                        );
-                      }}
-                    </Form.Item>
-                    <Form.Item
-                      name={[certField.name, 'oneTimeLoading']}
-                      label="One Time Loading"
-                      valuePropName="checked"
-                    >
-                      <Switch />
-                    </Form.Item>
-                    <Form.Item
-                      name={[certField.name, 'usage']}
-                      label="Usage Option"
-                    >
-                      <Select
-                        style={{ width: '50%' }}
-                        options={Object.values(USAGE_OPTION).map((u) => ({ value: u, label: u }))}
-                      />
-                    </Form.Item>
-                    <Form.Item
-                      noStyle
-                      shouldUpdate={(prev, curr) =>
-                        prev.streamSettings?.tlsSettings?.certificates?.[certField.name]?.usage
-                        !== curr.streamSettings?.tlsSettings?.certificates?.[certField.name]?.usage
-                      }
-                    >
-                      {({ getFieldValue }) => {
-                        const usage = getFieldValue([
-                          'streamSettings', 'tlsSettings', 'certificates',
-                          certField.name, 'usage',
-                        ]);
-                        if (usage !== 'issue') return null;
-                        return (
-                          <Form.Item
-                            name={[certField.name, 'buildChain']}
-                            label="Build Chain"
-                            valuePropName="checked"
-                          >
-                            <Switch />
+                              <MinusOutlined /> Remove
+                            </Button>
                           </Form.Item>
-                        );
-                      }}
-                    </Form.Item>
-                  </div>
-                ))}
-              </>
-            )}
-          </Form.List>
+                        )}
+                        <Form.Item
+                          noStyle
+                          shouldUpdate={(prev, curr) =>
+                            prev.streamSettings?.tlsSettings?.certificates?.[certField.name]?.useFile
+                            !== curr.streamSettings?.tlsSettings?.certificates?.[certField.name]?.useFile
+                          }
+                        >
+                          {({ getFieldValue }) => {
+                            const useFile = getFieldValue([
+                              'streamSettings', 'tlsSettings', 'certificates',
+                              certField.name, 'useFile',
+                            ]);
+                            return useFile ? (
+                              <>
+                                <Form.Item
+                                  name={[certField.name, 'certificateFile']}
+                                  label={t('pages.inbounds.publicKey')}
+                                >
+                                  <Input />
+                                </Form.Item>
+                                <Form.Item
+                                  name={[certField.name, 'keyFile']}
+                                  label={t('pages.inbounds.privatekey')}
+                                >
+                                  <Input />
+                                </Form.Item>
+                              </>
+                            ) : (
+                              <>
+                                <Form.Item
+                                  name={[certField.name, 'certificate']}
+                                  label={t('pages.inbounds.publicKey')}
+                                  normalize={(v) => typeof v === 'string'
+                                    ? v.split('\n')
+                                    : v}
+                                  getValueProps={(v) => ({
+                                    value: Array.isArray(v) ? v.join('\n') : v,
+                                  })}
+                                >
+                                  <TextArea autoSize={{ minRows: 3, maxRows: 8 }} />
+                                </Form.Item>
+                                <Form.Item
+                                  name={[certField.name, 'key']}
+                                  label={t('pages.inbounds.privatekey')}
+                                  normalize={(v) => typeof v === 'string'
+                                    ? v.split('\n')
+                                    : v}
+                                  getValueProps={(v) => ({
+                                    value: Array.isArray(v) ? v.join('\n') : v,
+                                  })}
+                                >
+                                  <TextArea autoSize={{ minRows: 3, maxRows: 8 }} />
+                                </Form.Item>
+                              </>
+                            );
+                          }}
+                        </Form.Item>
+                        <Form.Item
+                          name={[certField.name, 'oneTimeLoading']}
+                          label="One Time Loading"
+                          valuePropName="checked"
+                        >
+                          <Switch />
+                        </Form.Item>
+                        <Form.Item
+                          name={[certField.name, 'usage']}
+                          label="Usage Option"
+                        >
+                          <Select
+                            style={{ width: '50%' }}
+                            options={Object.values(USAGE_OPTION).map((u) => ({ value: u, label: u }))}
+                          />
+                        </Form.Item>
+                        <Form.Item
+                          noStyle
+                          shouldUpdate={(prev, curr) =>
+                            prev.streamSettings?.tlsSettings?.certificates?.[certField.name]?.usage
+                            !== curr.streamSettings?.tlsSettings?.certificates?.[certField.name]?.usage
+                          }
+                        >
+                          {({ getFieldValue }) => {
+                            const usage = getFieldValue([
+                              'streamSettings', 'tlsSettings', 'certificates',
+                              certField.name, 'usage',
+                            ]);
+                            if (usage !== 'issue') return null;
+                            return (
+                              <Form.Item
+                                name={[certField.name, 'buildChain']}
+                                label="Build Chain"
+                                valuePropName="checked"
+                              >
+                                <Switch />
+                              </Form.Item>
+                            );
+                          }}
+                        </Form.Item>
+                      </div>
+                    ))}
+                  </>
+                )}
+              </Form.List>
 
-          <Form.Item name={['streamSettings', 'tlsSettings', 'echServerKeys']} label="ECH key">
-            <Input />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'tlsSettings', 'settings', 'echConfigList']}
-            label="ECH config"
-          >
-            <Input />
-          </Form.Item>
-          <Form.Item label=" ">
-            <Space>
-              <Button type="primary" loading={saving} onClick={getNewEchCert}>
-                Get New ECH Cert
-              </Button>
-              <Button danger onClick={clearEchCert}>Clear</Button>
-            </Space>
-          </Form.Item>
+              <Form.Item name={['streamSettings', 'tlsSettings', 'echServerKeys']} label="ECH key">
+                <Input />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'tlsSettings', 'settings', 'echConfigList']}
+                label="ECH config"
+              >
+                <Input />
+              </Form.Item>
+              <Form.Item label=" ">
+                <Space>
+                  <Button type="primary" loading={saving} onClick={getNewEchCert}>
+                    Get New ECH Cert
+                  </Button>
+                  <Button danger onClick={clearEchCert}>Clear</Button>
+                </Space>
+              </Form.Item>
             </>
           );
         }}
@@ -2723,121 +2723,121 @@ export default function InboundFormModal({
           if (sec !== 'reality') return null;
           return (
             <>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'show']}
-            label="Show"
-            valuePropName="checked"
-          >
-            <Switch />
-          </Form.Item>
-          <Form.Item name={['streamSettings', 'realitySettings', 'xver']} label="Xver">
-            <InputNumber min={0} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'settings', 'fingerprint']}
-            label="uTLS"
-          >
-            <Select
-              options={Object.values(UTLS_FINGERPRINT).map((fp) => ({ value: fp, label: fp }))}
-            />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'target']}
-            label={
-              <>
-                Target{' '}
-                <SyncOutlined className="random-icon" onClick={randomizeRealityTarget} />
-              </>
-            }
-          >
-            <Input />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'serverNames']}
-            label={
-              <>
-                SNI{' '}
-                <SyncOutlined className="random-icon" onClick={randomizeRealityTarget} />
-              </>
-            }
-          >
-            <Select mode="tags" tokenSeparators={[',']} style={{ width: '100%' }} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'maxTimediff']}
-            label="Max Time Diff (ms)"
-          >
-            <InputNumber min={0} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'minClientVer']}
-            label="Min Client Ver"
-          >
-            <Input placeholder="25.9.11" />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'maxClientVer']}
-            label="Max Client Ver"
-          >
-            <Input placeholder="25.9.11" />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'shortIds']}
-            label={
-              <>
-                Short IDs{' '}
-                <SyncOutlined className="random-icon" onClick={randomizeShortIds} />
-              </>
-            }
-          >
-            <Select mode="tags" tokenSeparators={[',']} style={{ width: '100%' }} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'settings', 'spiderX']}
-            label="SpiderX"
-          >
-            <Input />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'settings', 'publicKey']}
-            label={t('pages.inbounds.publicKey')}
-          >
-            <Input.TextArea autoSize={{ minRows: 1, maxRows: 4 }} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'privateKey']}
-            label={t('pages.inbounds.privatekey')}
-          >
-            <Input.TextArea autoSize={{ minRows: 1, maxRows: 4 }} />
-          </Form.Item>
-          <Form.Item label=" ">
-            <Space>
-              <Button type="primary" loading={saving} onClick={genRealityKeypair}>
-                Get New Cert
-              </Button>
-              <Button danger onClick={clearRealityKeypair}>Clear</Button>
-            </Space>
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'mldsa65Seed']}
-            label="mldsa65 Seed"
-          >
-            <Input.TextArea autoSize={{ minRows: 2, maxRows: 6 }} />
-          </Form.Item>
-          <Form.Item
-            name={['streamSettings', 'realitySettings', 'settings', 'mldsa65Verify']}
-            label="mldsa65 Verify"
-          >
-            <Input.TextArea autoSize={{ minRows: 2, maxRows: 6 }} />
-          </Form.Item>
-          <Form.Item label=" ">
-            <Space>
-              <Button type="primary" loading={saving} onClick={genMldsa65}>
-                Get New Seed
-              </Button>
-              <Button danger onClick={clearMldsa65}>Clear</Button>
-            </Space>
-          </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'show']}
+                label="Show"
+                valuePropName="checked"
+              >
+                <Switch />
+              </Form.Item>
+              <Form.Item name={['streamSettings', 'realitySettings', 'xver']} label="Xver">
+                <InputNumber min={0} />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'settings', 'fingerprint']}
+                label="uTLS"
+              >
+                <Select
+                  options={Object.values(UTLS_FINGERPRINT).map((fp) => ({ value: fp, label: fp }))}
+                />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'target']}
+                label={
+                  <>
+                    Target{' '}
+                    <SyncOutlined className="random-icon" onClick={randomizeRealityTarget} />
+                  </>
+                }
+              >
+                <Input />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'serverNames']}
+                label={
+                  <>
+                    SNI{' '}
+                    <SyncOutlined className="random-icon" onClick={randomizeRealityTarget} />
+                  </>
+                }
+              >
+                <Select mode="tags" tokenSeparators={[',']} style={{ width: '100%' }} />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'maxTimediff']}
+                label="Max Time Diff (ms)"
+              >
+                <InputNumber min={0} />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'minClientVer']}
+                label="Min Client Ver"
+              >
+                <Input placeholder="25.9.11" />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'maxClientVer']}
+                label="Max Client Ver"
+              >
+                <Input placeholder="25.9.11" />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'shortIds']}
+                label={
+                  <>
+                    Short IDs{' '}
+                    <SyncOutlined className="random-icon" onClick={randomizeShortIds} />
+                  </>
+                }
+              >
+                <Select mode="tags" tokenSeparators={[',']} style={{ width: '100%' }} />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'settings', 'spiderX']}
+                label="SpiderX"
+              >
+                <Input />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'settings', 'publicKey']}
+                label={t('pages.inbounds.publicKey')}
+              >
+                <Input.TextArea autoSize={{ minRows: 1, maxRows: 4 }} />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'privateKey']}
+                label={t('pages.inbounds.privatekey')}
+              >
+                <Input.TextArea autoSize={{ minRows: 1, maxRows: 4 }} />
+              </Form.Item>
+              <Form.Item label=" ">
+                <Space>
+                  <Button type="primary" loading={saving} onClick={genRealityKeypair}>
+                    Get New Cert
+                  </Button>
+                  <Button danger onClick={clearRealityKeypair}>Clear</Button>
+                </Space>
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'mldsa65Seed']}
+                label="mldsa65 Seed"
+              >
+                <Input.TextArea autoSize={{ minRows: 2, maxRows: 6 }} />
+              </Form.Item>
+              <Form.Item
+                name={['streamSettings', 'realitySettings', 'settings', 'mldsa65Verify']}
+                label="mldsa65 Verify"
+              >
+                <Input.TextArea autoSize={{ minRows: 2, maxRows: 6 }} />
+              </Form.Item>
+              <Form.Item label=" ">
+                <Space>
+                  <Button type="primary" loading={saving} onClick={genMldsa65}>
+                    Get New Seed
+                  </Button>
+                  <Button danger onClick={clearMldsa65}>Clear</Button>
+                </Space>
+              </Form.Item>
             </>
           );
         }}
@@ -3037,9 +3037,9 @@ export default function InboundFormModal({
               : []),
             ...(streamEnabled
               ? [
-                  { key: 'stream', label: t('pages.inbounds.streamTab'), children: streamTab, forceRender: true },
-                  { key: 'security', label: t('pages.inbounds.securityTab'), children: securityTab, forceRender: true },
-                ]
+                { key: 'stream', label: t('pages.inbounds.streamTab'), children: streamTab, forceRender: true },
+                { key: 'security', label: t('pages.inbounds.securityTab'), children: securityTab, forceRender: true },
+              ]
               : []),
             { key: 'sniffing', label: t('pages.inbounds.sniffingTab'), children: sniffingTab, forceRender: true },
             { key: 'advanced', label: t('pages.xray.advancedTemplate'), children: advancedTab, forceRender: true },
diff --git a/frontend/src/pages/xray/OutboundFormModal.tsx b/frontend/src/pages/xray/OutboundFormModal.tsx
index c12cfd6f..00b10bf9 100644
--- a/frontend/src/pages/xray/OutboundFormModal.tsx
+++ b/frontend/src/pages/xray/OutboundFormModal.tsx
@@ -98,7 +98,7 @@ function isMuxAllowed(protocol: string, flow: string, network: string): boolean
 }
 
 const NETWORK_OPTIONS: { value: string; label: string }[] = [
-  { value: 'tcp', label: 'TCP (RAW)' },
+  { value: 'tcp', label: 'RAW' },
   { value: 'kcp', label: 'mKCP' },
   { value: 'ws', label: 'WebSocket' },
   { value: 'grpc', label: 'gRPC' },
@@ -684,11 +684,11 @@ export default function OutboundFormModal({
                                         ['settings', 'fragment'],
                                         checked
                                           ? {
-                                              packets: 'tlshello',
-                                              length: '100-200',
-                                              interval: '10-20',
-                                              maxSplit: '300-400',
-                                            }
+                                            packets: 'tlshello',
+                                            length: '100-200',
+                                            interval: '10-20',
+                                            maxSplit: '300-400',
+                                          }
                                           : { packets: '', length: '', interval: '', maxSplit: '' },
                                       );
                                     }}
@@ -1143,20 +1143,20 @@ export default function OutboundFormModal({
                                           ['streamSettings', 'tcpSettings', 'header'],
                                           checked
                                             ? {
-                                                type: 'http',
-                                                request: {
-                                                  version: '1.1',
-                                                  method: 'GET',
-                                                  path: ['/'],
-                                                  headers: {},
-                                                },
-                                                response: {
-                                                  version: '1.1',
-                                                  status: '200',
-                                                  reason: 'OK',
-                                                  headers: {},
-                                                },
-                                              }
+                                              type: 'http',
+                                              request: {
+                                                version: '1.1',
+                                                method: 'GET',
+                                                path: ['/'],
+                                                headers: {},
+                                              },
+                                              response: {
+                                                version: '1.1',
+                                                status: '200',
+                                                reason: 'OK',
+                                                headers: {},
+                                              },
+                                            }
                                             : { type: 'none' },
                                         )
                                       }
@@ -1771,8 +1771,8 @@ export default function OutboundFormModal({
                               normalize={(v: unknown) =>
                                 Array.isArray(v)
                                   ? v
-                                      .map((x) => Number(x))
-                                      .filter((n) => Number.isInteger(n) && n > 0)
+                                    .map((x) => Number(x))
+                                    .filter((n) => Number.isInteger(n) && n > 0)
                                   : []
                               }
                             >
diff --git a/web/service/inbound.go b/web/service/inbound.go
index 64063157..e37465b9 100644
--- a/web/service/inbound.go
+++ b/web/service/inbound.go
@@ -467,12 +467,12 @@ func (s *InboundService) AddInbound(inbound *model.Inbound) (*model.Inbound, boo
 	// Normalize streamSettings based on protocol
 	s.normalizeStreamSettings(inbound)
 
-	exist, err := s.checkPortConflict(inbound, 0)
+	conflict, err := s.checkPortConflict(inbound, 0)
 	if err != nil {
 		return inbound, false, err
 	}
-	if exist {
-		return inbound, false, common.NewError("Port already exists:", inbound.Port)
+	if conflict != nil {
+		return inbound, false, common.NewError(conflict.String())
 	}
 
 	inbound.Tag, err = s.resolveInboundTag(inbound, 0)
@@ -735,12 +735,12 @@ func (s *InboundService) UpdateInbound(inbound *model.Inbound) (*model.Inbound,
 	// Normalize streamSettings based on protocol
 	s.normalizeStreamSettings(inbound)
 
-	exist, err := s.checkPortConflict(inbound, inbound.Id)
+	conflict, err := s.checkPortConflict(inbound, inbound.Id)
 	if err != nil {
 		return inbound, false, err
 	}
-	if exist {
-		return inbound, false, common.NewError("Port already exists:", inbound.Port)
+	if conflict != nil {
+		return inbound, false, common.NewError(conflict.String())
 	}
 
 	oldInbound, err := s.GetInbound(inbound.Id)
diff --git a/web/service/port_conflict.go b/web/service/port_conflict.go
index ea13e074..a153fda9 100644
--- a/web/service/port_conflict.go
+++ b/web/service/port_conflict.go
@@ -20,17 +20,17 @@ const (
 	transportUDP
 )
 
-// conflicts is true when the two masks share any L4 transport.
-func (b transportBits) conflicts(o transportBits) bool { return b&o != 0 }
-
 // inboundTransports returns the L4 transports the given inbound listens on.
 // always returns at least one bit (falls back to tcp on parse errors), so
-// the validator never gets looser than the old port-only check.
+// no parse failure can silently let a real socket collision through.
 //
 // the rules:
 //   - hysteria, wireguard: udp regardless of streamSettings
-//   - streamSettings.network=kcp: udp
-//   - shadowsocks: whatever settings.network says ("tcp" / "udp" / "tcp,udp")
+//   - streamSettings.network=kcp or quic: udp (both ride on udp at L4)
+//   - shadowsocks: settings.network ("tcp" / "udp" / "tcp,udp"), overrides
+//     the streamSettings-derived bit when present
+//   - tunnel (xray dokodemo-door): same shape via settings.allowedNetwork
+//     (3x-ui's wrapper renames the field)
 //   - mixed (socks/http combo): tcp + udp when settings.udp is true
 //   - everything else: tcp
 func inboundTransports(protocol model.Protocol, streamSettings, settings string) transportBits {
@@ -42,7 +42,7 @@ func inboundTransports(protocol model.Protocol, streamSettings, settings string)
 
 	var bits transportBits
 
-	// peek at streamSettings.network to spot udp transports like kcp.
+	// peek at streamSettings.network to spot udp-based transports.
 	// parse errors are non-fatal: missing or weird streamSettings just
 	// keeps the default tcp bit below.
 	network := ""
@@ -54,23 +54,31 @@ func inboundTransports(protocol model.Protocol, streamSettings, settings string)
 			}
 		}
 	}
-	if network == "kcp" {
+	switch network {
+	case "kcp", "quic":
 		bits |= transportUDP
-	} else {
+	default:
 		bits |= transportTCP
 	}
 
-	// some protocols also listen on udp on the same port via their own
-	// settings json. parse and merge.
+	// a few protocols carry their L4 choice in settings instead of (or in
+	// addition to) streamSettings: SS / Tunnel via a CSV field that wins
+	// outright, Mixed via an additive udp boolean.
 	if settings != "" {
 		var st map[string]any
 		if json.Unmarshal([]byte(settings), &st) == nil {
 			switch protocol {
-			case model.Shadowsocks:
-				// shadowsocks settings.network controls both tcp and udp,
-				// independently of streamSettings. the field takes "tcp",
-				// "udp", or "tcp,udp". if it's set, it wins outright.
-				if n, ok := st["network"].(string); ok && n != "" {
+			case model.Shadowsocks, model.Tunnel:
+				// shadowsocks exposes settings.network, tunnel exposes
+				// settings.allowedNetwork (3x-ui's wrapper around xray's
+				// dokodemo-door). both carry "tcp" / "udp" / "tcp,udp"
+				// and, when present, win outright over the streamSettings-
+				// derived default; absent/empty keeps the inferred bit (tcp).
+				key := "network"
+				if protocol == model.Tunnel {
+					key = "allowedNetwork"
+				}
+				if n, ok := st[key].(string); ok && n != "" {
 					bits = 0
 					for part := range strings.SplitSeq(n, ",") {
 						switch strings.TrimSpace(part) {
@@ -113,10 +121,47 @@ func isAnyListen(s string) bool {
 	return s == "" || s == "0.0.0.0" || s == "::" || s == "::0"
 }
 
-// checkPortConflict reports whether adding/updating an inbound on
-// (listen, port) would clash with an existing inbound. unlike the old
-// port-only check, this one understands that tcp/443 and udp/443 are
-// independent sockets in linux and may coexist on the same address.
+// portConflictDetail describes the existing inbound that an add/update
+// would collide with. it carries enough context for the API layer to
+// render a user-actionable error ("port 443 (tcp) already used by
+// inbound 'my-vless' (#7) on *") instead of the historical opaque
+// "Port exists". Transports holds only the bits the two inbounds
+// actually share, not the existing inbound's full transport mask.
+type portConflictDetail struct {
+	InboundID  int
+	Remark     string
+	Tag        string
+	Listen     string
+	Port       int
+	Transports transportBits
+}
+
+// String renders the detail as a single-line, user-facing summary.
+func (d *portConflictDetail) String() string {
+	name := d.Remark
+	if name == "" {
+		name = d.Tag
+	}
+	if name == "" {
+		name = fmt.Sprintf("#%d", d.InboundID)
+	} else {
+		name = fmt.Sprintf("'%s' (#%d)", name, d.InboundID)
+	}
+	listen := d.Listen
+	if isAnyListen(listen) {
+		listen = "*"
+	}
+	return fmt.Sprintf("port %d (%s) already used by inbound %s on %s",
+		d.Port, transportTagSuffix(d.Transports), name, listen)
+}
+
+// checkPortConflict reports the existing inbound (if any) that adding
+// or updating an inbound on (listen, port) would clash with. nil result
+// means no conflict.
+//
+// unlike the old port-only check, this one understands that tcp/443 and
+// udp/443 are independent sockets in linux and may coexist on the same
+// address.
 //
 // node scope: inbounds with different NodeID run on different physical
 // machines (local panel xray vs a remote node, or two remote nodes),
@@ -125,7 +170,7 @@ func isAnyListen(s string) bool {
 //
 // the listen-overlap rule (specific addr conflicts with any-addr on the
 // same port, both directions) is preserved from the previous check.
-func (s *InboundService) checkPortConflict(inbound *model.Inbound, ignoreId int) (bool, error) {
+func (s *InboundService) checkPortConflict(inbound *model.Inbound, ignoreId int) (*portConflictDetail, error) {
 	db := database.GetDB()
 
 	var candidates []*model.Inbound
@@ -134,7 +179,7 @@ func (s *InboundService) checkPortConflict(inbound *model.Inbound, ignoreId int)
 		q = q.Where("id != ?", ignoreId)
 	}
 	if err := q.Find(&candidates).Error; err != nil {
-		return false, err
+		return nil, err
 	}
 
 	newBits := inboundTransports(inbound.Protocol, inbound.StreamSettings, inbound.Settings)
@@ -145,11 +190,21 @@ func (s *InboundService) checkPortConflict(inbound *model.Inbound, ignoreId int)
 		if !listenOverlaps(c.Listen, inbound.Listen) {
 			continue
 		}
-		if inboundTransports(c.Protocol, c.StreamSettings, c.Settings).conflicts(newBits) {
-			return true, nil
+		existingBits := inboundTransports(c.Protocol, c.StreamSettings, c.Settings)
+		shared := existingBits & newBits
+		if shared == 0 {
+			continue
 		}
+		return &portConflictDetail{
+			InboundID:  c.Id,
+			Remark:     c.Remark,
+			Tag:        c.Tag,
+			Listen:     c.Listen,
+			Port:       c.Port,
+			Transports: shared,
+		}, nil
 	}
-	return false, nil
+	return nil, nil
 }
 
 // sameNode reports whether two NodeID pointers refer to the same xray
diff --git a/web/service/port_conflict_test.go b/web/service/port_conflict_test.go
index bb79d370..93c2752e 100644
--- a/web/service/port_conflict_test.go
+++ b/web/service/port_conflict_test.go
@@ -2,6 +2,7 @@ package service
 
 import (
 	"path/filepath"
+	"strings"
 	"sync"
 	"testing"
 
@@ -137,7 +138,7 @@ func TestCheckPortConflict_TCPandUDPCoexistOnSamePort(t *testing.T) {
 	if err != nil {
 		t.Fatalf("checkPortConflict: %v", err)
 	}
-	if exist {
+	if exist != nil {
 		t.Fatalf("vless/tcp and hysteria2/udp on the same port must be allowed to coexist")
 	}
 }
@@ -159,7 +160,7 @@ func TestCheckPortConflict_TCPCollidesWithTCP(t *testing.T) {
 	if err != nil {
 		t.Fatalf("checkPortConflict: %v", err)
 	}
-	if !exist {
+	if exist == nil {
 		t.Fatalf("two tcp inbounds on the same port must still conflict")
 	}
 }
@@ -181,7 +182,7 @@ func TestCheckPortConflict_UDPCollidesWithUDP(t *testing.T) {
 	if err != nil {
 		t.Fatalf("checkPortConflict: %v", err)
 	}
-	if !exist {
+	if exist == nil {
 		t.Fatalf("two udp inbounds on the same port must conflict")
 	}
 }
@@ -201,7 +202,7 @@ func TestCheckPortConflict_ShadowsocksDualListenBlocksBoth(t *testing.T) {
 		Protocol:       model.VLESS,
 		StreamSettings: `{"network":"tcp"}`,
 	}
-	if exist, err := svc.checkPortConflict(tcpClash, 0); err != nil || !exist {
+	if exist, err := svc.checkPortConflict(tcpClash, 0); err != nil || exist == nil {
 		t.Fatalf("tcp inbound should clash with shadowsocks tcp,udp; exist=%v err=%v", exist, err)
 	}
 
@@ -211,7 +212,7 @@ func TestCheckPortConflict_ShadowsocksDualListenBlocksBoth(t *testing.T) {
 		Port:     443,
 		Protocol: model.Hysteria,
 	}
-	if exist, err := svc.checkPortConflict(udpClash, 0); err != nil || !exist {
+	if exist, err := svc.checkPortConflict(udpClash, 0); err != nil || exist == nil {
 		t.Fatalf("udp inbound should clash with shadowsocks tcp,udp; exist=%v err=%v", exist, err)
 	}
 }
@@ -229,7 +230,7 @@ func TestCheckPortConflict_DifferentPortNeverConflicts(t *testing.T) {
 		Protocol:       model.VLESS,
 		StreamSettings: `{"network":"tcp"}`,
 	}
-	if exist, err := svc.checkPortConflict(other, 0); err != nil || exist {
+	if exist, err := svc.checkPortConflict(other, 0); err != nil || exist != nil {
 		t.Fatalf("different port must not conflict; exist=%v err=%v", exist, err)
 	}
 }
@@ -251,7 +252,7 @@ func TestCheckPortConflict_ListenOverlapPreserved(t *testing.T) {
 		Protocol:       model.VLESS,
 		StreamSettings: `{"network":"tcp"}`,
 	}
-	if exist, err := svc.checkPortConflict(other, 0); err != nil || exist {
+	if exist, err := svc.checkPortConflict(other, 0); err != nil || exist != nil {
 		t.Fatalf("different specific listen must not conflict; exist=%v err=%v", exist, err)
 	}
 
@@ -263,7 +264,7 @@ func TestCheckPortConflict_ListenOverlapPreserved(t *testing.T) {
 		Protocol:       model.VLESS,
 		StreamSettings: `{"network":"tcp"}`,
 	}
-	if exist, err := svc.checkPortConflict(anyAddr, 0); err != nil || !exist {
+	if exist, err := svc.checkPortConflict(anyAddr, 0); err != nil || exist == nil {
 		t.Fatalf("any-addr on same port+transport must conflict with specific; exist=%v err=%v", exist, err)
 	}
 }
@@ -386,8 +387,8 @@ func TestCheckPortConflict_NodeScope(t *testing.T) {
 			if err != nil {
 				t.Fatalf("checkPortConflict: %v", err)
 			}
-			if got != c.want {
-				t.Fatalf("got conflict=%v, want %v", got, c.want)
+			if (got != nil) != c.want {
+				t.Fatalf("got conflict=%v, want %v", got != nil, c.want)
 			}
 		})
 	}
@@ -482,7 +483,113 @@ func TestCheckPortConflict_IgnoreSelfOnUpdate(t *testing.T) {
 	}
 
 	svc := &InboundService{}
-	if exist, err := svc.checkPortConflict(&existing, existing.Id); err != nil || exist {
+	if exist, err := svc.checkPortConflict(&existing, existing.Id); err != nil || exist != nil {
 		t.Fatalf("self-update must not be flagged as conflict; exist=%v err=%v", exist, err)
 	}
 }
+
+// streamSettings.network=quic rides on UDP at L4, so a QUIC inbound must
+// conflict with a UDP-only neighbour (hysteria) on the same port but not
+// with a TCP-only one. covers the gap left by the original kcp-only check.
+func TestCheckPortConflict_QUICTreatedAsUDP(t *testing.T) {
+	quic := &model.Inbound{
+		Tag:            "vless-quic-443",
+		Listen:         "0.0.0.0",
+		Port:           443,
+		Protocol:       model.VLESS,
+		StreamSettings: `{"network":"quic"}`,
+	}
+
+	t.Run("conflicts with hysteria/udp", func(t *testing.T) {
+		setupConflictDB(t)
+		seedInboundConflict(t, "hyst-443", "0.0.0.0", 443, model.Hysteria, ``, ``)
+		svc := &InboundService{}
+		if exist, err := svc.checkPortConflict(quic, 0); err != nil || exist == nil {
+			t.Fatalf("quic on same port as hysteria must conflict; exist=%v err=%v", exist, err)
+		}
+	})
+
+	t.Run("coexists with vless/tcp", func(t *testing.T) {
+		setupConflictDB(t)
+		seedInboundConflict(t, "vless-tcp-443", "0.0.0.0", 443, model.VLESS, `{"network":"tcp"}`, `{}`)
+		svc := &InboundService{}
+		if exist, err := svc.checkPortConflict(quic, 0); err != nil || exist != nil {
+			t.Fatalf("quic and tcp on same port must coexist; exist=%v err=%v", exist, err)
+		}
+	})
+}
+
+// tunnel (dokodemo-door) carries its L4 transport list in
+// settings.allowedNetwork, not settings.network. verify the predicate
+// picks the right field for each protocol.
+func TestCheckPortConflict_TunnelAllowedNetwork(t *testing.T) {
+	setupConflictDB(t)
+	seedInboundConflict(t, "tunnel-udp-443", "0.0.0.0", 443, model.Tunnel, ``, `{"allowedNetwork":"udp"}`)
+
+	svc := &InboundService{}
+
+	// tcp inbound on same port should coexist with udp-only tunnel.
+	tcpNeighbour := &model.Inbound{
+		Tag:            "vless-443",
+		Listen:         "0.0.0.0",
+		Port:           443,
+		Protocol:       model.VLESS,
+		StreamSettings: `{"network":"tcp"}`,
+	}
+	if exist, err := svc.checkPortConflict(tcpNeighbour, 0); err != nil || exist != nil {
+		t.Fatalf("tunnel/udp and vless/tcp on same port must coexist; exist=%v err=%v", exist, err)
+	}
+
+	// udp neighbour (hysteria) on same port must conflict.
+	udpNeighbour := &model.Inbound{
+		Tag:      "hyst-443",
+		Listen:   "0.0.0.0",
+		Port:     443,
+		Protocol: model.Hysteria,
+	}
+	if exist, err := svc.checkPortConflict(udpNeighbour, 0); err != nil || exist == nil {
+		t.Fatalf("tunnel/udp and hysteria on same port must conflict; exist=%v err=%v", exist, err)
+	}
+}
+
+// the rich conflict detail surfaced to the user must name the offending
+// inbound (by remark when available) and the shared L4 transport(s).
+func TestCheckPortConflict_DetailMessage(t *testing.T) {
+	setupConflictDB(t)
+	seeded := &model.Inbound{
+		Tag:            "vless-443",
+		Remark:         "my-vless",
+		Enable:         true,
+		Listen:         "0.0.0.0",
+		Port:           443,
+		Protocol:       model.VLESS,
+		StreamSettings: `{"network":"tcp"}`,
+		Settings:       `{}`,
+	}
+	if err := database.GetDB().Create(seeded).Error; err != nil {
+		t.Fatalf("seed inbound: %v", err)
+	}
+
+	svc := &InboundService{}
+	candidate := &model.Inbound{
+		Tag:            "trojan-443",
+		Listen:         "0.0.0.0",
+		Port:           443,
+		Protocol:       model.Trojan,
+		StreamSettings: `{"network":"ws"}`,
+	}
+	got, err := svc.checkPortConflict(candidate, 0)
+	if err != nil || got == nil {
+		t.Fatalf("expected conflict, got=%v err=%v", got, err)
+	}
+	msg := got.String()
+	if !strings.Contains(msg, "my-vless") {
+		t.Fatalf("message should mention the conflicting inbound's remark; got %q", msg)
+	}
+	if !strings.Contains(msg, "tcp") {
+		t.Fatalf("message should mention the shared L4 transport; got %q", msg)
+	}
+	if !strings.Contains(msg, "443") {
+		t.Fatalf("message should mention the port; got %q", msg)
+	}
+}