commit 0d2c6277e103a87da5462ba8ec07abab80bc0da3
Author: alexey <a@bayrepo.ru>
Date:   Mon Mar 23 01:15:59 2026 +0300

    Added mod_rewrite for nginx module

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6f78aef
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,10 @@
+nginx-1.25.30
+.clangd
+.devcontainer
+Dockerfile
+logs
+nginx-1.25.3
+.zed
+tmpbuild
+
+
diff --git a/BUILD.md b/BUILD.md
new file mode 100644
index 0000000..fd09676
--- /dev/null
+++ b/BUILD.md
@@ -0,0 +1,182 @@
+# Package Build
+
+## Building a binary file using a Docker image
+
+To build the image, download and extract nginx to the project root:
+For example:
+```
+wget https://nginx.org/download/nginx-1.26.3.tar.gz
+tar xvf nginx-1.26.3.tar.gz
+```
+Next, build the image using the Dockerfile in the project root (build for almalinux:9):
+```
+docker build -t nginx-mod_rewrite .
+```
+
+We obtain an image with nginx and the built mod_rewrite.
+
+To run the image, you need to execute the command:
+```
+docker run --name nginx-mod_rewrite -p 8080:80 -p 8081:8081 nginx-mod_rewrite
+```
+
+## Building the package for a specified operating system
+
+In the project root there is a script `package_preparer.sh` that allows you to build an rpm or deb package for a specific operating system. Which OS and native nginx version the package will be built for depends on the image used.
+
+To build the package, run the command:
+```
+bash package_preparer.sh prepare "almalinux:9"
+```
+
+The build was tested on the following images:
+
+* almalinux:9
+* almalinux:8
+* rockylinux:9
+* ubuntu:24.04
+* debian:stable
+
+After the build, the packages will appear in the `tmpbuild` directory:
+```
+$ ls -1 tmpbuild/*.rpm
+tmpbuild/nginx-mod-rewrite-0.1-1.el9.src.rpm
+tmpbuild/nginx-mod-rewrite-0.1-1.el9.x86_64.rpm
+tmpbuild/nginx-mod-rewrite-debuginfo-0.1-1.el9.x86_64.rpm
+tmpbuild/nginx-mod-rewrite-debugsource-0.1-1.el9.x86_64.rpm
+```
+or
+```
+$ ls -1 tmpbuild/nginx-mod-rewrite*
+tmpbuild/nginx-mod-rewrite_0.1-1_amd64.buildinfo
+tmpbuild/nginx-mod-rewrite_0.1-1_amd64.changes
+tmpbuild/nginx-mod-rewrite_0.1-1_amd64.deb
+tmpbuild/nginx-mod-rewrite_0.1-1.dsc
+tmpbuild/nginx-mod-rewrite_0.1-1.tar.gz
+tmpbuild/nginx-mod-rewrite-0.1.tar.gz
+tmpbuild/nginx-mod-rewrite-dbgsym_0.1-1_amd64.deb
+```
+
+To ensure that the command
+```bash
+bash -x package_preparer.sh prepare "os-image"
+```
+works correctly, the following utilities must be installed and available on the system (each of which comes from a package supplied by your Linux distribution):
+
+| Utility | What it does in the `prepare` section | Package (Debian/Ubuntu) |
+|---------|---------------------------------------|--------------------------|
+| **`bash`** | Runs the script itself | already installed |
+| **`rm`, `mkdir`, `cp`, `find`, `head`, `gzip`, `tee`** | Cleans/creates directories, copies files, searches, compresses, logs | `coreutils` |
+| **`sed`** (GNU sed) | Parameterizes templates, removes/replaces strings | `sed` (GNU sed, the `sed` package from coreutils) |
+| **`awk`** | Extracts the version from `CHANGELOG`, generates the changelog file | `gawk` (or the `awk` package) |
+| **`tar`** | Creates tar archives, adds files | `tar` |
+| **`docker`** (commands `docker build`, `docker run`, `docker rmi`) | Builds a temporary image, runs a container, cleans up | `docker.io` / `docker-ce` + running **daemon** |
+
+> **Note on `sed`**  
+> The script uses extended regular expressions (`sed -E`) and in-place file modification (`sed -i`). This is the GNU variant of `sed`. On systems where `sed` is the BSD variant (e.g., macOS), the command `sed -E -i` will not work, so in such environments you need to install GNU `sed` (`gsed`) and replace calls with `gsed`.
+
+The Docker daemon must be running, and the user must have permission to use it (or be in the `docker` group).
+
+The main build occurs in a Docker container, so the base system does not get cluttered with extra packages. The set of utilities used by the script is present in the distribution by default, so you only need to install Docker.
+
+The builder analyzes the nginx version installed in the distribution and performs the build in an environment with source files of the same nginx version, using commands similar to those used when building nginx from the distribution.
+
+## Manual build from sources
+
+If you need to build the module yourself, you need to run the following commands.
+
+Here is an example for AlmaLinux 9.
+
+Install the necessary build packages:
+```
+dnf -y install openssl-devel pcre-devel zlib-devel gcc gcc-c++ make wget
+```
+
+In the project root:
+```
+bash package_preparer.sh download 1.22.1
+```
+
+You can specify any available version on the website `https://nginx.org/ru/download.html`; it will be downloaded and extracted into the current directory.
+
+Then change directory into nginx-1.22.1:
+```
+cd nginx-1.22.1
+```
+and set the build configuration. Here is an example configuration, it may differ; this example is a typical configuration:
+```
+./configure \
+    --with-compat \
+    --add-dynamic-module=../modules/mod_rewrite \
+    --prefix=/etc/nginx \
+    --sbin-path=/usr/sbin/nginx \
+    --modules-path=/etc/nginx/modules \
+    --conf-path=/etc/nginx/nginx.conf \
+    --error-log-path=/var/log/nginx/error.log \
+    --http-log-path=/var/log/nginx/access.log \
+    --pid-path=/var/run/nginx.pid \
+    --lock-path=/var/run/nginx.lock \
+    --http-client-body-temp-path=/var/lib/nginx/body \
+    --http-proxy-temp-path=/var/lib/nginx/proxy \
+    --http-fastcgi-temp-path=/var/lib/nginx/fastcgi \
+    --http-uwsgi-temp-path=/var/lib/nginx/uwsgi \
+    --http-scgi-temp-path=/var/lib/nginx/scgi \
+    --with-http_ssl_module \
+    --with-http_v2_module \
+    --with-http_realip_module \
+    --with-http_gzip_static_module \
+    --with-http_stub_status_module \
+    --with-http_slice_module \
+    --with-http_dav_module \
+    --with-http_auth_request_module \
+    --with-http_secure_link_module \
+    --with-stream \
+    --with-stream_ssl_module \
+    --with-stream_realip_module \
+    --with-stream_ssl_preread_module \
+    --with-pcre-jit
+```
+
+During execution, the following should appear:
+```
+adding module in ../modules/mod_rewrite
+ + ngx_http_apache_rewrite_module was configured
+```
+
+You can add `--add-dynamic-module=../modules/mod_rewrite` to your nginx configuration.
+
+Next:
+```
+make modules
+```
+This command will build the module:
+```
+# ls -1 objs/ngx_http_apache_rewrite_module.so
+objs/ngx_http_apache_rewrite_module.so
+```
+Then you can move it to the nginx modules directory:
+```
+cp objs/ngx_http_apache_rewrite_module.so /etc/nginx/modules/
+```
+and load the module in the nginx configuration file:
+```
+
+cat /etc/nginx/nginx.conf
+
+load_module modules/ngx_http_apache_rewrite_module.so;
+
+...
+
+server {
+        ... 
+        HtaccessEnable on;
+
+        RewriteEngine On;
+
+        location / {
+         RewriteEngine On;
+
+        }
+
+    }
+```
diff --git a/BUILD.ru.md b/BUILD.ru.md
new file mode 100644
index 0000000..d3f983a
--- /dev/null
+++ b/BUILD.ru.md
@@ -0,0 +1,182 @@
+# Сборка пакета
+
+## Сборка бинарного файла с использованием docker-образа
+
+Для сборки образа скачайте и разархивируйте nginx в корень проекта:
+Например так:
+```
+wget https://nginx.org/download/nginx-1.26.3.tar.gz
+tar xvf nginx-1.26.3.tar.gz
+```
+Далее соберите образ, используя Dockerfile в корне проекта (сборка под almalinux:9):
+```
+docker build -t nginx-mod_rewrite .
+```
+
+Получаем образ с nginx и собранным mod_rewrite.
+
+Для запуска образа необходимо выполнить команду:
+```
+docker run --name nginx-mod_rewrite -p 8080:80 -p 8081:8081 nginx-mod_rewrite
+```
+
+## Сборка пакета под заданную операционную систему
+
+В корне проекта расположен скрипт `package_preparer.sh`, который позволяет собрать rpm или deb пакет под определенную операционную систему. Под какую операционную систему и нативную версию nginx будет собран пакет, зависит от используемого образа.
+
+Для сборки пакета необходимо запустить команду:
+```
+bash package_preparer.sh prepare "almalinux:9"
+```
+
+Сборка проверялась на образах:
+
+* almalinux:9
+* almalinux:8
+* rockylinux:9
+* ubuntu:24.04
+* debian:stable
+
+
+
+После сборки собранные пакеты появятся в каталоге tmpbuild:
+```
+$ ls -1 tmpbuild/*.rpm
+tmpbuild/nginx-mod-rewrite-0.1-1.el9.src.rpm
+tmpbuild/nginx-mod-rewrite-0.1-1.el9.x86_64.rpm
+tmpbuild/nginx-mod-rewrite-debuginfo-0.1-1.el9.x86_64.rpm
+tmpbuild/nginx-mod-rewrite-debugsource-0.1-1.el9.x86_64.rpm
+```
+или
+```
+$ ls -1 tmpbuild/nginx-mod-rewrite*
+tmpbuild/nginx-mod-rewrite_0.1-1_amd64.buildinfo
+tmpbuild/nginx-mod-rewrite_0.1-1_amd64.changes
+tmpbuild/nginx-mod-rewrite_0.1-1_amd64.deb
+tmpbuild/nginx-mod-rewrite_0.1-1.dsc
+tmpbuild/nginx-mod-rewrite_0.1-1.tar.gz
+tmpbuild/nginx-mod-rewrite-0.1.tar.gz
+tmpbuild/nginx-mod-rewrite-dbgsym_0.1-1_amd64.deb
+```
+
+Для того чтобы команда
+```bash
+bash -x package_preparer.sh prepare "os-image"
+```
+работала корректно, в системе должны быть установлены и доступны следующие утилиты (каждая из которых берётся из пакета, поставляемого в вашем дистрибутиве Linux):
+
+| Утилита | Что делает в `prepare`‑разделе | Пакет (Debian/Ubuntu) |
+|---------|--------------------------------|------------------------|
+| **`bash`** | Запуск самого скрипта | уже установлен |
+| **`rm`, `mkdir`, `cp`, `find`, `head`, `gzip`, `tee`** | Очистка/создание каталогов, копирование файлов, поиск, сжатие, логирование | `coreutils` |
+| **`sed`** (GNU sed) | Параметризация шаблонов, удаление/замена строк | `sed` (GNU sed, пакет `sed` из coreutils) |
+| **`awk`** | Извлечение версии из `CHANGELOG`, генерация changelog‑файла | `gawk` (или `awk`‑пакет) |
+| **`tar`** | Создание tar‑архива, добавление файлов | `tar` |
+| **`docker`** (команды `docker build`, `docker run`, `docker rmi`) | Построение временного образа, запуск контейнера, очистка | `docker.io` / `docker-ce` + работающий **daemon** |
+
+> **Замечание по `sed`**  
+> В скрипте используются расширенные регулярные выражения (`sed -E`) и модификация файла на месте (`sed -i`). Это GNU‑вариант `sed`. На системах, где `sed` – BSD‑вариант (например, macOS), команда `sed -E -i` не будет работать, поэтому в таких окружениях нужно установить GNU‑`sed` (`gsed`) и заменить вызовы на `gsed`.
+
+Docker‑демон должен быть запущен, и пользователь должен иметь права на его использование (или быть в группе `docker`).
+
+Основная сборка происходит в docker‑контейнере, поэтому основная система не засоряется лишними пакетами. Основной набор утилит, используемых скриптом, присутствует в дистрибутиве по умолчанию, поэтому необходимо только установить docker.
+
+Сборщик анализирует версию nginx, установленную в дистрибутиве, и производит сборку в окружении исходных файлов аналогичной версии nginx дистрибутива, а также командами, аналогичными, которые использовались при сборке nginx из дистрибутива.
+
+## Ручная сборка из исходников
+
+Если же необходимо собрать модуль самостоятельно, необходимо выполнить следующие команды.
+
+Привожу пример для Almalinux 9.
+
+Установите необходимые пакеты для сборки:
+```
+dnf -y install openssl-devel pcre-devel zlib-devel gcc gcc-c++ make wget
+```
+
+В корне проекта:
+```
+bash package_preparer.sh download 1.22.1
+```
+
+В качестве версии можно задать любую доступную на сайте `https://nginx.org/ru/download.html`, она будет скачана и распакована в текущий каталог.
+
+Далее перейти в папку nginx-1.22.1:
+```
+cd nginx-1.22.1
+```
+и задать конфигурацию сборки. Я привожу пример конфигурации, она может отличаться; данный пример — это типичная конфигурация:
+```
+./configure \
+    --with-compat \
+    --add-dynamic-module=../modules/mod_rewrite \
+    --prefix=/etc/nginx \
+    --sbin-path=/usr/sbin/nginx \
+    --modules-path=/etc/nginx/modules \
+    --conf-path=/etc/nginx/nginx.conf \
+    --error-log-path=/var/log/nginx/error.log \
+    --http-log-path=/var/log/nginx/access.log \
+    --pid-path=/var/run/nginx.pid \
+    --lock-path=/var/run/nginx.lock \
+    --http-client-body-temp-path=/var/lib/nginx/body \
+    --http-proxy-temp-path=/var/lib/nginx/proxy \
+    --http-fastcgi-temp-path=/var/lib/nginx/fastcgi \
+    --http-uwsgi-temp-path=/var/lib/nginx/uwsgi \
+    --http-scgi-temp-path=/var/lib/nginx/scgi \
+    --with-http_ssl_module \
+    --with-http_v2_module \
+    --with-http_realip_module \
+    --with-http_gzip_static_module \
+    --with-http_stub_status_module \
+    --with-http_slice_module \
+    --with-http_dav_module \
+    --with-http_auth_request_module \
+    --with-http_secure_link_module \
+    --with-stream \
+    --with-stream_ssl_module \
+    --with-stream_realip_module \
+    --with-stream_ssl_preread_module \
+    --with-pcre-jit
+```
+
+Во время выполнения команды должно появиться:
+```
+adding module in ../modules/mod_rewrite
+ + ngx_http_apache_rewrite_module was configured
+```
+
+Можно добавить `--add-dynamic-module=../modules/mod_rewrite` в свою конфигурацию nginx.
+
+Далее:
+```
+make modules
+```
+данная команда соберет модуль:
+```
+# ls -1 objs/ngx_http_apache_rewrite_module.so
+objs/ngx_http_apache_rewrite_module.so
+```
+Далее его можно переложить в каталог модулей nginx:
+```
+cp objs/ngx_http_apache_rewrite_module.so /etc/nginx/modules/
+```
+и подключить модуль в файле конфигурации nginx:
+```
+cat /etc/nginx/nginx.conf
+
+load_module modules/ngx_http_apache_rewrite_module.so;
+
+...
+
+server {
+        ...
+        HtaccessEnable on;
+
+        RewriteEngine On;
+
+        location / {
+         RewriteEngine On;
+
+        }
+
+    }
diff --git a/CHANGELOG b/CHANGELOG
new file mode 100644
index 0000000..80977be
--- /dev/null
+++ b/CHANGELOG
@@ -0,0 +1,8 @@
+version: 0.1-1
+
+--
+* Sat Mar 14 2026 Alexey BayRepo <a@bayrepo.ru> - 0.1-1
+- Added debian/ubuntu build
+
+* Fri Mar 13 2026 Alexey BayRepo <a@bayrepo.ru> - 0.1-0
+- New package mod_rewrite for nginx
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..4ee4e1c
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,228 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Alexey BayRepo
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+/*
+ * Copyright (C) 2002-2021 Igor Sysoev
+ * Copyright (C) 2011-2021 Nginx, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..8e41ac7
--- /dev/null
+++ b/README.md
@@ -0,0 +1,470 @@
+## Apache mod_rewrite Compatibility Module for Nginx
+
+This module provides Apache's `mod_rewrite` compatibility for Nginx, enabling `.htaccess` file support and standard rewrite rules.
+
+---
+
+# Configuration Directives
+
+The following directives are available in this module:
+
+### 1. RewriteEngine
+
+**Purpose:** Enable or disable the rewrite engine.
+
+| Context        | Available Levels                            |
+|----------------|---------------------------------------------|
+| `main`, `server`, `location` | ✓ All three levels supported |
+
+**Syntax:**
+```nginx
+RewriteEngine on|off
+```
+
+**Possible Values:**
+- `on`  - Enable rewrite engine
+- `off` - Disable rewrite engine (default)
+
+**Example in nginx.conf:**
+```nginx
+http {
+    server {
+        RewriteEngine on;
+
+        location /blog/ {
+            # Rules apply here
+        }
+
+        location /static/ {
+            RewriteEngine off;  # Disable for this location
+        }
+    }
+}
+```
+
+---
+
+### 2. RewriteRule
+
+**Purpose:** Define a rewrite rule that matches a URL pattern and substitutes it with a new value.
+
+| Context        | Available Levels                            |
+|----------------|---------------------------------------------|
+| `server`, `location`      | ✓ Server and Location level           |
+| `.htaccess`               | ✓ Supported in .htaccess files          |
+
+**Syntax:**
+```nginx
+RewriteRule pattern substitution [flags]
+```
+
+**Parameters:**
+
+- **pattern** - Regular expression to match the URL (supports backreferences $1, $2, etc.)
+  - Pattern can be prefixed with `!` for negation
+  - `-` as substitution means "no substitution" (only match for conditions)
+
+- **substitution** - Target URL or file path to rewrite to
+  - Can be a relative path (`/new/path`) or absolute redirect (`http://example.com/new`)
+
+**Flags:** `[flag1,flag2,...]` (optional):
+
+| Flag | Abbreviation | Description |
+|------|--------------|-------------|
+| `B`  | -            | Escape backreferences in output (prevent URL encoding issues) |
+| `C`  | Chain        | Chain this rule with the next one (requires previous match) |
+| `D`  | DPI          | Discard path info after substitution |
+| `E`  | Env=var:val  | Set an environment variable for later use (FastCGI integration) |
+| `F`  | Forbidden    | Return HTTP 403 Forbidden status |
+| `G`  | Gone         | Return HTTP 410 Gone status |
+| `L`  | Last         | Stop processing rules after this one |
+| `N`  | Next=limit   | Loop (retry) up to N times for infinite rewriting prevention |
+| `P`  | Proxy        | Proxy the request internally (Phase 2) |
+| `Q`  | QSA          | Append original query string to substitution URL |
+| `Q`  | QSD          | Discard original query string |
+| `Q`  | QSL          | Set "query string last" marker |
+| `R`  | Redirect=code| Perform external redirect with status code (301, 302, 307) or: Permanent, Temp, SeeOther |
+| `S`  | Skip=N       | Skip N subsequent rules after this one |
+| `T`  | Type=mime    | Force specific MIME type for the response |
+| `NC` | -            | Case-insensitive matching |
+| `NOESCAPE` | -      | Do not escape special characters in output |
+| `END`| -            | Stop all rewriting and pass to content phase |
+
+**Example:**
+```nginx
+# Redirect /old-path/ to /new-path/ (permanent redirect)
+RewriteRule ^old-path/(.*)$ /new-path/$1 [R=301,L]
+
+# Condition-based rewrite (chain)
+RewriteCond %REQUEST_URI !^/admin/
+RewriteRule ^admin/(.*)$ /login.php?user=$1 [NC,E,END]
+
+# In .htaccess:
+RewriteEngine on
+RewriteCond %{HTTP_HOST} ^www\.example\.com$ [OR]
+RewriteCond %{HTTPS} off
+RewriteRule ^(.*)$ https://example.com/$1 [R=301,L]
+```
+
+---
+
+### 3. RewriteCond
+
+**Purpose:** Define conditions that must be met before a `RewriteRule` is applied. Multiple conditions are ANDed together; OR flag can change this behavior.
+
+| Context        | Available Levels                            |
+|----------------|---------------------------------------------|
+| `server`, `location`      | ✓ Server and Location level           |
+| `.htaccess`               | ✓ Supported in .htaccess files          |
+
+**Syntax:**
+```nginx
+RewriteCond input_string pattern [flags]
+```
+
+**Parameters:**
+
+- **input_string** - Variable or string to test (e.g., `%REQUEST_URI`, `%HTTP_HOST`, `%REQUEST_FILENAME`)
+  - Common variables: `REQUEST_URI`, `HTTP_HOST`, `REQUEST_METHOD`, `REQUEST_FILENAME`
+
+- **pattern** - Test pattern for the condition:
+  - **File tests:** `-f` (file exists), `-d` (directory exists), `-x` (executable), `-s` (non-zero size)
+  - **Link tests:** `-h` or `-l` (hard/soft link), `-L` (link target exists)
+  - **Integer comparisons:** `-lt`, `-le`, `-eq`, `-gt`, `-ge`, `-ne`
+  - **String comparisons:** `=`, `>`, `<`, `>=`, `<=`
+  - **Regular expressions:** Any regex pattern
+
+- **flags** (optional):
+  - `NC` - Case-insensitive matching
+  - `OR` / `ornext` - OR logic between conditions (instead of AND)
+
+**Examples:**
+```nginx
+# Condition: file exists
+RewriteCond %REQUEST_FILENAME -f
+
+# Condition: not a directory
+RewriteCond %REQUEST_FILENAME !-d
+
+# Condition: string comparison
+RewriteCond %{HTTP_HOST} ^www\.example\.com$ [NC]
+
+# Integer comparison (file size > 1024 bytes)
+RewriteCond %REQUEST_FILENAME -s
+RewriteCond %{FILESIZE} -gt 1024
+
+# Multiple conditions with OR logic
+RewriteCond %{HTTP_HOST} ^www\.example\.com$ [OR]
+RewriteCond %{HTTPS} off
+
+# Regular expression pattern
+RewriteCond %{REQUEST_URI} ^/old/(.*)$
+```
+
+---
+
+### 4. RewriteBase
+
+**Purpose:** Set the base URL path for relative substitutions in rewrite rules.
+
+| Context        | Available Levels                            |
+|----------------|---------------------------------------------|
+| `location`      | ✓ Location level only                  |
+| `.htaccess`     | ✓ Supported in .htaccess files          |
+
+**Syntax:**
+```nginx
+RewriteBase /path/
+```
+
+**Parameters:**
+- Must start with `/` and end with `/` (trailing slash required)
+
+**Example:**
+```nginx
+# Inside a specific location
+location /blog/ {
+    RewriteBase /blog/
+
+    # Relative substitution resolves to: /blog/news.html
+    RewriteRule ^news\.html$ news.php [L]
+}
+
+# In .htaccess:
+RewriteEngine on
+RewriteBase /subdir/
+RewriteRule ^index\.html$ home.php [L]
+```
+
+---
+
+### 5. RewriteOptions
+
+**Purpose:** Configure rewrite behavior options that affect rule inheritance and processing order.
+
+| Context        | Available Levels                            |
+|----------------|---------------------------------------------|
+| `main`, `server`, `location` | ✓ All three levels supported |
+
+**Syntax:**
+```nginx
+RewriteOptions option1 [option2 ...]
+```
+
+**Possible Options:**
+
+| Option          | Description |
+|-----------------|-------------|
+| `Inherit`       | Inherit rules from parent locations/servers (default behavior) |
+| `InheritBefore` | Process parent rules before child rules |
+
+**Example:**
+```nginx
+http {
+    server {
+        RewriteOptions Inherit
+
+        location /parent/ {
+            RewriteRule ^parent/(.*)$ /new/$1 [L]
+        }
+
+        location /child/ {
+            # Inherits rules from parent by default with 'Inherit' option
+            RewriteBase /child/
+        }
+    }
+}
+```
+
+---
+
+### 6. RewriteMap
+
+**Purpose:** Define name-value mappings for lookup tables in rewrite expressions.
+
+| Context        | Available Levels                            |
+|----------------|---------------------------------------------|
+| `server`        | ✓ Server level only                     |
+| `.htaccess`     | ✗ Not supported in .htaccess            |
+
+**Syntax:**
+```nginx
+RewriteMap name type:source
+```
+
+**Parameters:**
+
+- **name** - Map identifier (used as variable like `%MAPNAME:value`)
+- **type** - Type of map:
+  - `int` - Internal function (supported: `tolower`, `toupper`, `escape`, `unescape`)
+  - `txt` - Text file lookup (not supported yet)
+  - `rnd` - Random lookup (not supported yet)
+  - `prg` - Program lookup (not supported yet)
+
+**Example:**
+```nginx
+server {
+    # Map to lowercase version of hostname
+    RewriteMap lc int:tolower
+
+    server_name example.com;
+
+    location / {
+        # Use mapped value in rule
+        RewriteRule ^lc/([^/]+)$ /redirect/$1 [L]
+    }
+}
+
+# Usage in rules:
+RewriteRule ^(.*)$ /%lc:$1 [L]
+```
+
+---
+
+### 7. HtaccessEnable
+
+**Purpose:** Enable or disable `.htaccess` file parsing for the server/location.
+
+| Context        | Available Levels                            |
+|----------------|---------------------------------------------|
+| `main`, `server`      | ✓ Main and Server level only          |
+| `.htaccess`     | ✗ Not supported in .htaccess            |
+
+**Syntax:**
+```nginx
+HtaccessEnable on|off
+```
+
+**Parameters:**
+- `on`  - Enable `.htaccess` parsing
+- `off` - Disable `.htaccess` parsing (default)
+
+**Example:**
+```nginx
+http {
+    server {
+        HtaccessEnable on
+
+        # .htaccess files will be searched upward from the request path
+        location /subdir/ {
+            root /var/www/html;
+        }
+    }
+}
+
+# In nginx.conf, you can also enable at http level:
+http {
+    HtaccessEnable on;
+
+    server {
+        # Inherits setting from http level
+    }
+}
+```
+
+---
+
+### 8. HtaccessName
+
+**Purpose:** Specify an alternative filename for `.htaccess` files.
+
+| Context        | Available Levels                            |
+|----------------|---------------------------------------------|
+| `main`, `server`      | ✓ Main and Server level only          |
+| `.htaccess`     | ✗ Not supported in .htaccess            |
+
+**Syntax:**
+```nginx
+HtaccessName filename
+```
+
+**Parameters:**
+- Any string (default is `.htaccess`)
+
+**Example:**
+```nginx
+server {
+    HtaccessName .webconfig
+
+    # Will look for .webconfig files instead of .htaccess
+    location / {
+        root /var/www/html;
+    }
+}
+
+# In .htaccess:
+HtaccessEnable on
+HtaccessName .custom_htac
+```
+
+---
+
+### 9. RewriteFallBack
+
+**Purpose:** Specify an alternative fallback path when the rewritten file doesn't exist (instead of default `/index.php`). This directive can only be used in `.htaccess` files and is read by `ngx_htaccess_parse_file_from_ha()`. The fallback path is cached per request and retrieved in `ngx_http_apache_rewrite_url_register_hook_with_fallback()`.
+
+| Context        | Available Levels                            |
+|----------------|---------------------------------------------|
+| `.htaccess`     | ✓ Supported only in .htaccess files      |
+
+**Syntax:**
+```apache
+RewriteFallBack /path/to/fallback.php
+```
+
+**Parameters:**
+- Path must start with `/` (required)
+- Default fallback is `/index.php` if not specified
+
+**Example in .htaccess:**
+```apache
+# Use custom fallback when file not found
+RewriteFallBack /custom/app.php
+
+# Fallback will redirect to /custom/app.php?query_string instead of /index.php
+RewriteEngine on
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteRule ^(.*)$ index.php [QSA,L]
+```
+
+**Example with query string:**
+```apache
+RewriteFallBack /handler.php?lang=ru
+
+# When file doesn't exist, request is redirected to the fallback path
+# preserving the original query string if present
+```
+
+---
+
+## Configuration Levels Summary
+
+| Directive       | http/main | server | location | .htaccess |
+|-----------------|-----------|--------|----------|-----------|
+| RewriteEngine   | ✓         | ✓      | ✓        | ✓         |
+| RewriteRule     | -         | ✓      | ✓        | ✓         |
+| RewriteCond     | -         | ✓      | ✓        | ✓         |
+| RewriteBase     | -         | -      | ✓        | ✓         |
+| RewriteOptions  | ✓         | ✓      | ✓        | -         |
+| RewriteMap      | -         | ✓      | -        | -         |
+| HtaccessEnable  | ✓         | ✓      | -        | -         |
+| HtaccessName    | ✓         | ✓      | -        | -         |
+| RewriteFallBack | ✗         | ✗      | -        | ✓         |
+
+---
+
+## .htaccess File Format
+
+`.htaccess` files follow the Apache format:
+
+```apache
+# Comments start with #
+RewriteEngine on
+
+RewriteCond %{REQUEST_URI} ^/old/(.*)$
+RewriteRule ^old/(.*)$ /new/$1 [R=301,L]
+
+# Multiple conditions (AND logic by default)
+RewriteCond %{HTTP_HOST} www\.example\.com$
+RewriteCond %{HTTPS} off
+RewriteRule (.*) https://www.example.com/$1 [R=301,L]
+
+RewriteBase /subdir/
+RewriteFallBack /custom/fallback.php
+RewriteCond !-f
+RewriteCond !-d
+RewriteRule ^(.*)$ index.php?route=$1 [QSA,L]
+```
+
+When a file doesn't exist after URL rewriting, the module falls back to:
+1. `RewriteFallBack` path if specified in `.htaccess`, or
+2. `/index.php` as default fallback
+
+---
+
+## Module Features
+
+### FastCGI Integration
+The module automatically passes environment variables (set via `[E=VAR:VAL]` flags) to FastCGI applications without manual configuration.
+
+### Environment Variables
+Environment variables persist across request phases and are available for downstream modules.
+
+### .htaccess Caching
+`.htaccess` files are cached by modification time in the request pool to improve performance on repeated requests. The `RewriteFallBack` directive is also stored in the cache entry and retrieved when needed.
+
+### RewriteFallBack Directive
+The `RewriteFallBack` directive allows customizing the fallback path used when a rewritten file doesn't exist:
+
+1. **Caching:** The fallback path from `.htaccess` is cached per request to avoid repeated parsing
+2. **Fallback Logic:** When `try_files` fails, the module redirects to the configured fallback instead of `/index.php`
+3. **Query String Preservation:** Original query string is preserved and appended to fallback path
+
+---
+
+## Notes
+
+- Rewrite rules are processed in order as defined in configuration or `.htaccess` files
+- The `[L]` flag stops processing at the current rule
+- The `[N]` flag enables looping for infinite redirects prevention (max 10,000 rounds)
+- Location-level rules override server-level rules unless `Inherit` option is set
diff --git a/README.ru.md b/README.ru.md
new file mode 100644
index 0000000..f9644ac
--- /dev/null
+++ b/README.ru.md
@@ -0,0 +1,481 @@
+## Модуль совместимости Apache mod_rewrite для Nginx
+
+Этот модуль обеспечивает совместимость Apache `mod_rewrite` для Nginx, позволяя использовать файлы `.htaccess` и стандартные правила переписывания.
+
+---
+
+# Директивы конфигурации
+
+Ниже перечислены доступные директивы в этом модуле:
+
+### 1. RewriteEngine
+
+**Назначение:** Включить или отключить механизм переписывания.
+
+| Контекст | Доступные уровни |
+|----------|------------------|
+| `main`, `server`, `location` | ✓ Поддерживаются все три уровня |
+
+**Синтаксис:**
+```nginx
+RewriteEngine on|off
+```
+
+**Возможные значения:**
+- `on`  - Включить механизм переписывания
+- `off` - Отключить механизм переписывания (по умолчанию)
+
+**Пример в nginx.conf:**
+```nginx
+http {
+    server {
+        RewriteEngine on;
+
+        location /blog/ {
+            # Правила применяются здесь
+        }
+
+        location /static/ {
+            RewriteEngine off;  # Отключить для этой локации
+        }
+    }
+}
+```
+
+---
+
+
+### 2. RewriteRule
+
+**Назначение:** Определить правило переписывания, которое сопоставляет шаблон URL и заменяет его новым значением.
+
+| Контекст | Доступные уровни |
+|----------|------------------|
+| `server`, `location` | ✓ Уровни сервера и локации |
+| `.htaccess` | ✓ Поддерживается в файлах .htaccess |
+
+**Синтаксис:**
+```nginx
+RewriteRule pattern substitution [flags]
+```
+
+**Параметры:**
+
+- **pattern** - Регулярное выражение для сопоставления URL (поддерживаются обратные ссылки $1, $2 и т.д.)
+  - Паттерн может быть префиксирован `!` для отрицания
+  - `-` в качестве замены означает "нет замены" (только проверка условий)
+
+- **substitution** - Целевой URL или путь файла для переписывания
+  - Может быть относительным путем (`/new/path`) или абсолютным перенаправлением (`http://example.com/new`)
+
+**Флаги:** `[flag1,flag2,...]` (необязательно):
+
+| Флаг | Короткая запись | Описание |
+|------|-----------------|----------|
+| `B`  | -               | Экранировать обратные ссылки в выводе (предотвратить проблемы с кодировкой URL) |
+| `C`  | Chain           | Присоединить это правило к следующему (требует предыдущего совпадения) |
+| `D`  | DPI             | Отбросить информацию о пути после замены |
+| `E`  | Env=var:val     | Установить переменную окружения для последующего использования (FastCGI интеграция) |
+| `F`  | Forbidden       | Вернуть статус HTTP 403 Forbidden |
+| `G`  | Gone            | Вернуть статус HTTP 410 Gone |
+| `L`  | Last            | Остановить обработку правил после этого |
+| `N`  | Next=limit      | Цикл (повторить) до N раз для предотвращения бесконечных переписываний |
+| `P`  | Proxy           | Проксировать запрос внутренне (Фаза 2) |
+| `Q`  | QSA             | Прикрепить исходную строку запроса к URL замены |
+| `Q`  | QSD             | Удалить исходную строку запроса |
+| `Q`  | QSL             | Установить маркер "query string last" |
+| `R`  | Redirect=code   | Выполнить внешнее перенаправление со статусом (301, 302, 307) или: Permanent, Temp, SeeOther |
+| `S`  | Skip=N          | Пропустить N последующих правил после этого |
+| `T`  | Type=mime       | Принудительно установить MIME-тип для ответа |
+| `NC` | -               | Непрерывное сопоставление без учета регистра |
+| `NOESCAPE` | -           | Не экранировать специальные символы в выводе |
+| `END`| -               | Остановить все переписывания и перейти к фазе контента |
+
+**Пример:**
+```nginx
+# Перенаправление /old-path/ в /new-path/ (постоянное перенаправление)
+RewriteRule ^old-path/(.*)$ /new-path/$1 [R=301,L]
+
+# Условное переписывание (цепочка)
+RewriteCond %REQUEST_URI !^/admin/
+RewriteRule ^admin/(.*)$ /login.php?user=$1 [NC,E,END]
+
+# В .htaccess:
+RewriteEngine on
+RewriteCond %{HTTP_HOST} ^www\.example\.com$ [OR]
+RewriteCond %{HTTPS} off
+RewriteRule ^(.*)$ https://example.com/$1 [R=301,L]
+```
+
+---
+
+
+### 3. RewriteCond
+
+**Назначение:** Определить условия, которые должны быть выполнены, прежде чем будет применено правило `RewriteRule`. Множественные условия объединяются по умолчанию (AND); можно изменить это с помощью флага OR.
+
+| Контекст | Доступные уровни |
+|----------|------------------|
+| `server`, `location` | ✓ Уровни сервера и локации |
+| `.htaccess` | ✓ Поддерживается в файлах .htaccess |
+
+**Синтаксис:**
+```nginx
+RewriteCond input_string pattern [flags]
+```
+
+**Параметры:**
+
+- **input_string** - Переменная или строка для проверки (например, `%REQUEST_URI`, `%HTTP_HOST`, `%REQUEST_METHOD`, `%REQUEST_FILENAME`)
+  - Общие переменные: `REQUEST_URI`, `HTTP_HOST`, `REQUEST_METHOD`, `REQUEST_FILENAME`
+
+- **pattern** - Шаблон проверки:
+  - **Тесты файлов:** `-f` (файл существует), `-d` (директория существует), `-x` (исполняемый), `-s` (не нулевой размер)
+  - **Тесты ссылок:** `-h` или `-l` (жёсткая/мягкая ссылка), `-L` (цель ссылки существует)
+  - **Сравнение целых чисел:** `-lt`, `-le`, `-eq`, `-gt`, `-ge`, `-ne`
+  - **Сравнение строк:** `=`, `>`, `<`, `>=`, `<=`
+  - **Регулярные выражения:** любой шаблон regex
+
+- **flags** (необязательно):
+  - `NC` - Не чувствительно к регистру
+  - `OR` / `ornext` - Логика OR между условиями (вместо AND)
+
+**Примеры:**
+```nginx
+# Условие: файл существует
+RewriteCond %REQUEST_FILENAME -f
+
+# Условие: не директория
+RewriteCond %REQUEST_FILENAME !-d
+
+# Сравнение строк
+RewriteCond %{HTTP_HOST} ^www\.example\.com$ [NC]
+
+# Сравнение целых чисел (размер файла > 1024 байт)
+RewriteCond %REQUEST_FILENAME -s
+RewriteCond %{FILESIZE} -gt 1024
+
+# Множественные условия с OR
+RewriteCond %{HTTP_HOST} ^www\.example\.com$ [OR]
+RewriteCond %{HTTPS} off
+
+# Регулярный шаблон
+RewriteCond %{REQUEST_URI} ^/old/(.*)$
+```
+
+---
+
+
+### 4. RewriteBase
+
+**Назначение:** Установить базовый URL-путь для относительных замен в правилах переписывания.
+
+| Контекст | Доступные уровни |
+|----------|------------------|
+| `location` | ✓ Только уровень локации |
+| `.htaccess` | ✓ Поддерживается в файлах .htaccess |
+
+**Синтаксис:**
+```nginx
+RewriteBase /path/
+```
+
+**Параметры:**
+- Должен начинаться с `/` и заканчиваться `/` (обязательный слеш)
+
+**Пример:**
+```nginx
+# Внутри конкретной локации
+location /blog/ {
+    RewriteBase /blog/
+
+    # Относительная замена разрешается: /blog/news.html
+    RewriteRule ^news\.html$ news.php [L]
+}
+
+# В .htaccess:
+RewriteEngine on
+RewriteBase /subdir/
+RewriteRule ^index\.html$ home.php [L]
+```
+
+---
+
+
+### 5. RewriteOptions
+
+**Назначение:** Настроить параметры поведения переписывания, которые влияют на наследование правил и порядок их обработки.
+
+| Контекст | Доступные уровни |
+|----------|------------------|
+| `main`, `server`, `location` | ✓ Все три уровня поддерживаются |
+
+**Синтаксис:**
+```nginx
+RewriteOptions option1 [option2 ...]
+```
+
+**Возможные опции:**
+
+| Опция          | Описание |
+|----------------|----------|
+| `Inherit`      | Наследовать правила из родительских локаций/серверов (поведение по умолчанию) |
+| `InheritBefore` | Обрабатывать правила родительских локаций до правил дочерних |
+
+**Пример:**
+```nginx
+http {
+    server {
+        RewriteOptions Inherit
+
+        location /parent/ {
+            RewriteRule ^parent/(.*)$ /new/$1 [L]
+        }
+
+        location /child/ {
+            # Наследует правила от родителя по умолчанию с опцией 'Inherit'
+            RewriteBase /child/
+        }
+    }
+}
+```
+
+---
+
+
+### 6. RewriteMap
+
+**Назначение:** Определить имя‑значение карты для поиска таблиц в выражениях переписывания.
+
+| Контекст | Доступные уровни |
+|----------|------------------|
+| `server` | ✓ Только уровень сервера |
+| `.htaccess` | ✗ Не поддерживается в .htaccess |
+
+**Синтаксис:**
+```nginx
+RewriteMap name type:source
+```
+
+**Параметры:**
+
+- **name** - Идентификатор карты (используется как переменная, например `%MAPNAME:value`)
+- **type** - Тип карты:
+  - `int` - Внутренняя функция (поддерживаемые: `tolower`, `toupper`, `escape`, `unescape`)
+  - `txt` - Поиск по текстовому файлу (пока не реализовано)
+  - `rnd` - Поиск по случайному (пока не реализовано)
+  - `prg` - Поиск по программе (пока не реализовано)
+
+**Пример:**
+```nginx
+server {
+    # Карта к нижнему регистру имени хоста
+    RewriteMap lc int:tolower
+
+    server_name example.com;
+
+    location / {
+        # Использовать сопоставленное значение в правиле
+        RewriteRule ^lc/([^/]+)$ /redirect/$1 [L]
+    }
+}
+
+# Использование в правилах:
+RewriteRule ^(.*)$ /%lc:$1 [L]
+```
+
+---
+
+
+### 7. HtaccessEnable
+
+**Назначение:** Включить или отключить разбор файлов `.htaccess` для сервера/локации.
+
+| Контекст | Доступные уровни |
+|----------|------------------|
+| `main`, `server` | ✓ Только уровни основного и сервера |
+| `.htaccess` | ✗ Не поддерживается в .htaccess |
+
+**Синтаксис:**
+```nginx
+HtaccessEnable on|off
+```
+
+**Параметры:**
+- `on`  - Включить разбор `.htaccess`
+- `off` - Отключить разбор `.htaccess` (по умолчанию)
+
+**Пример:**
+```nginx
+http {
+    server {
+        HtaccessEnable on
+
+        # Файлы .htaccess будут искаться вверх от пути запроса
+        location /subdir/ {
+            root /var/www/html;
+        }
+    }
+}
+
+# В nginx.conf, можно включить на уровне http:
+http {
+    HtaccessEnable on;
+
+    server {
+        # Наследует настройку из уровня http
+    }
+}
+```
+
+---
+
+
+### 8. HtaccessName
+
+**Назначение:** Указать альтернативное имя файла для файлов `.htaccess`.
+
+| Контекст | Доступные уровни |
+|----------|------------------|
+| `main`, `server` | ✓ Только уровни основного и сервера |
+| `.htaccess` | ✗ Не поддерживается в .htaccess |
+
+**Синтаксис:**
+```nginx
+HtaccessName filename
+```
+
+**Параметры:**
+- Любая строка (по умолчанию `.htaccess`)
+
+**Пример:**
+```nginx
+server {
+    HtaccessName .webconfig
+
+    # Будет искать файлы .webconfig вместо .htaccess
+    location / {
+        root /var/www/html;
+    }
+}
+
+# В .htaccess:
+HtaccessEnable on
+HtaccessName .custom_htac
+```
+
+---
+
+### 9. RewriteFallBack
+
+**Назначение:** Указать альтернативный путь отката, если переписанный файл не существует (вместо стандартного `/index.php`). Эта директива может использоваться только в файлах `.htaccess` и читается функцией `ngx_htaccess_parse_file_from_ha()`. Путь отката кэшируется для каждого запроса и извлекается в `ngx_http_apache_rewrite_url_register_hook_with_fallback()`.
+
+| Контекст        | Доступные уровни                            |
+|-----------------|----------------------------------------------|
+| `.htaccess`     | ✓ Поддерживается только в файлах .htaccess  |
+
+**Синтаксис:**
+```apache
+RewriteFallBack /path/to/fallback.php
+```
+
+**Параметры:**
+- Путь должен начинаться с `/` (обязательно)
+- По умолчанию путь отката – `/index.php`, если не указан
+
+**Пример в .htaccess:**
+```apache
+# Использовать пользовательский откат, если файл не найден
+RewriteFallBack /custom/app.php
+
+# Откат перенаправит на /custom/app.php?query_string вместо /index.php
+RewriteEngine on
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteRule ^(.*)$ index.php [QSA,L]
+```
+
+**Пример с параметром строки запроса:**
+```apache
+RewriteFallBack /handler.php?lang=ru
+
+# Если файл не существует, запрос будет перенаправлен на путь отката
+# с сохранением исходной строки запроса, если она присутствует
+```
+
+---
+
+## Сводка уровней конфигурации
+
+| Директива       | http/main | server | location | .htaccess |
+|------------------|-----------|--------|----------|-----------|
+| RewriteEngine   | ✓         | ✓      | ✓        | ✓         |
+| RewriteRule     | -         | ✓      | ✓        | ✓         |
+| RewriteCond     | -         | ✓      | ✓        | ✓         |
+| RewriteBase     | -         | -      | ✓        | ✓         |
+| RewriteOptions  | ✓         | ✓      | ✓        | -         |
+| RewriteMap      | -         | ✓      | -        | -         |
+| HtaccessEnable  | ✓         | ✓      | -        | -         |
+| HtaccessName    | ✓         | ✓      | -        | -         |
+| RewriteFallBack | ✗         | ✗      | -        | ✓         |
+
+---
+
+
+## Формат файла .htaccess
+
+Файлы `.htaccess` следуют формату Apache:
+
+```apache
+# Комментарии начинаются с #
+RewriteEngine on
+
+RewriteCond %{REQUEST_URI} ^/old/(.*)$
+RewriteRule ^old/(.*)$ /new/$1 [R=301,L]
+
+# Множественные условия (логика AND по умолчанию)
+RewriteCond %{HTTP_HOST} www\.example\.com$
+RewriteCond %{HTTPS} off
+RewriteRule (.*) https://www.example.com/$1 [R=301,L]
+
+RewriteBase /subdir/
+RewriteFallBack /custom/fallback.php
+RewriteCond !-f
+RewriteCond !-d
+RewriteRule ^(.*)$ index.php?route=$1 [QSA,L]
+```
+
+Если после переписывания URL файл не существует, модуль переходит к:
+1. Путь `RewriteFallBack`, если указан в `.htaccess`, или
+2. `/index.php` как стандартный откат
+```
+
+---
+
+
+## Возможности модуля
+
+### Интеграция с FastCGI
+Модуль автоматически передаёт переменные окружения (установленные через флаги `[E=VAR:VAL]`) в приложения FastCGI без дополнительной настройки.
+
+### Переменные окружения
+Переменные окружения сохраняются между фазами запроса и доступны downstream-модулям.
+
+### Кэширование .htaccess
+Файлы `.htaccess` кэшируются по времени изменения в памяти запроса, чтобы ускорить повторные запросы.
+
+### Директива RewriteFallBack
+Директива `RewriteFallBack` позволяет настроить путь отката, который используется, когда переписанный файл не существует:
+
+1. **Кеширование:** Путь отката из `.htaccess` кэшируется на каждый запрос, чтобы избежать повторного разборов.
+2. **Логика отката:** Когда `try_files` завершается неудачей, модуль перенаправляет на заданный откат вместо `/index.php`.
+3. **Сохранение строки запроса:** Исходная строка запроса сохраняется и добавляется к пути отката.
+```
+
+---
+
+## Заметки
+
+- Правила переписывания обрабатываются в порядке, определенном в конфигурации или файлах `.htaccess`
+- Флаг `[L]` останавливает обработку на текущем правиле
+- Флаг `[N]` включает цикл для предотвращения бесконечных перенаправлений (максимум 10 000 раундов)
+- Правила уровня локации переопределяют правила уровня сервера, если не задана опция `Inherit`
diff --git a/build b/build
new file mode 100644
index 0000000..d655dd6
--- /dev/null
+++ b/build
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+cd nginx-1.25.3
+make clean
+./configure     --with-compat     --add-dynamic-module=../modules/mod_rewrite     --prefix=/etc/nginx     --sbin-path=/usr/sbin/nginx     --modules-path=/etc/nginx/modules     --conf-path=/etc/nginx/nginx.conf     --error-log-path=/var/log/nginx/error.log     --http-log-path=/var/log/nginx/access.log     --pid-path=/var/run/nginx.pid     --lock-path=/var/run/nginx.lock     --http-client-body-temp-path=/var/lib/nginx/body     --http-proxy-temp-path=/var/lib/nginx/proxy     --http-fastcgi-temp-path=/var/lib/nginx/fastcgi     --http-uwsgi-temp-path=/var/lib/nginx/uwsgi     --http-scgi-temp-path=/var/lib/nginx/scgi     --with-http_ssl_module     --with-http_v2_module     --with-http_realip_module     --with-http_gzip_static_module     --with-http_stub_status_module     --with-http_slice_module     --with-http_dav_module     --with-http_auth_request_module     --with-http_secure_link_module     --with-stream     --with-stream_ssl_module     --with-stream_realip_module     --with-stream_ssl_preread_module     --with-pcre-jit --with-debug
+if [ $? -ne 0 ]; then
+    cd ..
+    exit 1
+fi
+make modules
+if [ $? -ne 0 ]; then
+    cd ..
+    exit 1
+fi
+make install
+if [ $? -ne 0 ]; then
+    cd ..
+    exit 1
+fi
+cd ..
diff --git a/cms/drupal-mod_headers/.htaccess b/cms/drupal-mod_headers/.htaccess
new file mode 100644
index 0000000..7d9bf81
--- /dev/null
+++ b/cms/drupal-mod_headers/.htaccess
@@ -0,0 +1,25 @@
+RewriteEngine on
+RewriteRule ^ - [E=protossl]
+RewriteCond %{HTTPS} on
+RewriteRule ^ - [E=protossl:s]
+RewriteRule ^ - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+RewriteRule "/\.|^\.(?!well-known/)" - [F]
+RewriteCond %{REQUEST_URI} ^(.*)?/(install\.php) [OR]
+RewriteCond %{REQUEST_URI} ^(.*)?/(rebuild\.php)
+RewriteCond %{REQUEST_URI} !core
+RewriteRule ^ %1/core/%2 [L,QSA,R=301]
+RewriteRule ^core/install\.php core/install.php?rewrite=ok [QSA,L]
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteCond %{REQUEST_URI} !=/favicon.ico
+RewriteRule ^ index.php [L]
+RewriteCond %{REQUEST_URI} !/core/[^/]*\.php$
+RewriteCond %{REQUEST_URI} !/core/modules/system/tests/https?\.php
+RewriteCond %{HTTP:Accept-encoding} gzip
+RewriteCond %{REQUEST_FILENAME}\.gz -s
+RewriteRule ^(.*css_[a-zA-Z0-9-_]+)\.css$ $1\.css\.gz [QSA]
+RewriteCond %{HTTP:Accept-encoding} gzip
+RewriteCond %{REQUEST_FILENAME}\.gz -s
+RewriteRule ^(.*js_[a-zA-Z0-9-_]+)\.js$ $1\.js\.gz [QSA]
+RewriteRule \.css\.gz$ - [T=text/css,E=no-gzip:1,E=no-brotli:1]
+RewriteRule \.js\.gz$ - [T=text/javascript,E=no-gzip:1,E=no-brotli:1]
diff --git a/cms/drupal/.htaccess b/cms/drupal/.htaccess
new file mode 100644
index 0000000..ab368bf
--- /dev/null
+++ b/cms/drupal/.htaccess
@@ -0,0 +1,19 @@
+  RewriteEngine on
+  RewriteRule ^ - [E=protossl]
+  RewriteCond %{HTTPS} on
+  RewriteRule ^ - [E=protossl:s]
+  RewriteRule ^ - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+  RewriteRule "/\.|^\.(?!well-known/)" - [F]
+  RewriteCond %{REQUEST_URI} ^(.*)?/(install\.php) [OR]
+  RewriteCond %{REQUEST_URI} ^(.*)?/(rebuild\.php)
+  RewriteCond %{REQUEST_URI} !core
+  RewriteRule ^ %1/core/%2 [L,QSA,R=301]
+  RewriteRule ^core/install\.php core/install.php?rewrite=ok [QSA,L]
+  RewriteCond %{REQUEST_FILENAME} !-f
+  RewriteCond %{REQUEST_FILENAME} !-d
+  RewriteCond %{REQUEST_URI} !=/favicon.ico
+  RewriteRule ^ index.php [L]
+  RewriteCond %{REQUEST_URI} !/core/[^/]*\.php$
+  RewriteCond %{REQUEST_URI} !/core/modules/system/tests/https?\.php
+  RewriteCond %{REQUEST_URI} !/core/modules/statistics/statistics\.php$
+  RewriteRule "^(.+/.*|autoload)\.php($|/)" - [F]
diff --git a/cms/drupal/.htpasswd b/cms/drupal/.htpasswd
new file mode 100644
index 0000000..4415402
--- /dev/null
+++ b/cms/drupal/.htpasswd
@@ -0,0 +1 @@
+# This is a test .htpasswd hidden file - should be blocked by RewriteRule "/\.|^\.(?!well-known/)" - [F]
diff --git a/cms/drupal/.well-known/robots.txt b/cms/drupal/.well-known/robots.txt
new file mode 100644
index 0000000..9ce043f
--- /dev/null
+++ b/cms/drupal/.well-known/robots.txt
@@ -0,0 +1,6 @@
+# This is a robots.txt file for Drupal site testing
+# Should be allowed by RewriteRule "/\.|^\.(?!well-known/)" - [F] exception
+
+User-agent: *
+Disallow: /admin/
+Allow: /
diff --git a/cms/drupal/README.md b/cms/drupal/README.md
new file mode 100644
index 0000000..1255ceb
--- /dev/null
+++ b/cms/drupal/README.md
@@ -0,0 +1,162 @@
+# Drupal .htaccess Test Structure
+
+## Directory Layout Overview
+
+```
+/test1/cms/drupal/
+├── core/                     - Drupal core directory tests
+│   ├── install.php           - Install script (protected by RewriteRule ^core/install\.php)
+│   ├── rebuild.php           - Rebuild script (protected by RewriteRule ^core/rebuild\.php)
+│   └── modules/system/tests/ - Tests directory with https/http.php files
+│       ├── https.php         - Test HTTPS test file (excluded from routing)
+│       └── http.php          - Test HTTP test file (excluded from routing)
+├── favicon.ico               - Existing favicon for !-f condition test
+├── index.php                 - Drupal entry point (routes non-existing files)
+│                                - Returns: "Drupal Content Route" page
+├── .htaccess                 - Hidden .htaccess file (blocked by hidden files rule)
+├── .htpasswd                 - Hidden .htpasswd file (blocked by hidden files rule)
+├── .well-known/              - Well-known directory (allowed exception)
+│   └── robots.txt            - Allowed file via exception (?!well-known)
+├── somedir/                  - Directory for testing !-d condition (200 OK)
+├── test-drupal-rewriterules.sh - Bash script to test all rules using curl
+└── README.md                 - This documentation file
+```
+
+## Apache Rules Explained - Drupal
+
+### 1. RewriteEngine Activation
+
+```apache
+RewriteEngine on
+```
+
+**Что делает:** Включает модуль mod_rewrite для этого каталога
+**Зачем нужно:** Без этого все правила rewrite не работают
+
+### 2. Protocol Variables (HTTP/HTTPS Detection)
+
+```apache
+RewriteRule ^ - [E=protossl]
+RewriteCond %{HTTPS} on
+RewriteRule ^ - [E=protossl:s]
+```
+
+**Что делает:** Устанавливает переменную окружения `protossl` = "https" или "http" в зависимости от HTTPS status
+**Зачем нужно:** Drupal использует это для генерации правильных ссылок (http vs https)
+- Если HTTPS off → protossl = "" (пусто, http)
+- Если HTTPS on → protossl = "s"
+
+### 3. HTTP Authorization Header Passing
+
+```apache
+RewriteRule ^ - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+```
+
+**Что делает:** Копирует Authorization header в переменную HTTP_AUTHORIZATION для PHP
+**Зачем нужно:** Drupal REST API требует эту переменную для аутентификации
+
+### 4. Hidden Files/Patterns Protection Rule
+
+```apache
+RewriteRule "/\.|^\.(?!well-known/)" - [F]
+```
+
+**Что делает:** Блокирует (403 Forbidden) файлы начинающиеся с точки, кроме .well-known/
+- `/\.` - блокирует /filename.хотя бы одна точка в path
+- `^\.(?!well-known/)` - блокирует /隐藏文件, но исключает /well-known/
+
+**Зачем нужно:** Защита от доступа к скрытым файлам (.htaccess, .htpasswd, .git)
+**Исключение:** .well-known/robots.txt разрешён (для SEO и security)
+
+### 5. Core install/rebuild.php Protection Rules
+
+```apache
+RewriteCond %{REQUEST_URI} ^(.*)?/(install\.php) [OR]
+RewriteCond %{REQUEST_URI} ^(.*)?/(rebuild\.php)
+RewriteCond %{REQUEST_URI} !core
+RewriteRule ^ %1/core/%2 [L,QSA,R=301]
+```
+
+**Что делает:** Редирект 301 с /install.php → /core/install.php, /rebuild.php → /core/rebuild.php
+**Зачем нужно:** Перемещает install/rebuild скрипты в core directory для безопасности
+
+### 6. Core install.php Rewrite
+
+```apache
+RewriteRule ^core/install\.php core/install.php?rewrite=ok [QSA,L]
+```
+
+**Что делает:** Переписывает запрос на core/install.php с добавлением параметра rewrite=ok
+**Зачем нужно:** Drupal internal handling для процесса установки
+
+### 7. Main Drupal Routing Rules (!-f, !-d)
+
+```apache
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteCond %{REQUEST_URI} !=/favicon.ico
+RewriteRule ^ index.php [L]
+```
+
+**Что делает:** Маршрутизирует через index.php все запросы на несуществующие файлы И директории, кроме favicon.ico
+**Зачем нужно:** "Чистые URL" Drupal (похоже на WordPress), routing через index.php
+
+### 8. Core Modules Tests Files Exceptions
+
+```apache
+RewriteCond %{REQUEST_URI} !/core/[^/]*\.php$
+RewriteCond %{REQUEST_URI} !/core/modules/system/tests/https?\.php
+```
+
+**Что делает:** Исключает из routing core/*.php и tests/https.php/http.php файлы
+**Зачем нужно:** Эти файлы должны обрабатываться напрямую, не через main index.php
+
+## Test Script Features
+
+The script includes test functions:
+1. **test_rule()** - checks HTTP status code only
+2. **test_rule_content()** - checks both status AND response body content
+
+## Multisite-Specific Testing Scenarios
+
+### Hidden Files Protection
+
+| URL | Правило | Ожидаемый результат |
+|-----|---------|---------------------|
+| `http://test.my.brp/.htaccess` | hidden files rule `/\.|^\.(?!well-known/)` | 403 Forbidden ✓ |
+| `http://test.my.brp/.htpasswd` | hidden files rule | 403 Forbidden ✓ |
+| `http://test.my.brp/.well-known/robots.txt` | well-known exception | 200 OK (allowed) ✓ |
+
+### Core install/rebuild.php Protection
+
+| URL | Правило | Ожидаемый результат |
+|-----|---------|---------------------|
+| `http://test.my.brp/install.php` | RewriteRule ^(.*)?/(install\.php) + core exclusion | 301 → /core/install.php ✓ |
+| `http://test.my.brp/rebuild.php` | RewriteRule ^(.*)?/(rebuild\.php) + core exclusion | 301 → /core/rebuild.php ✓ |
+
+### Core Files Routing Exceptions
+
+| URL | Правило | Ожидаемый результат |
+|-----|---------|---------------------|
+| `http://test.my.brp/core/install.php` | RewriteRule ^core/install\.php ... rewrite=ok parameter | 200 OK ✓ |
+| `http://test.my.brp/core/modules/system/tests/https.php` | tests exception !-https?\.php condition | 200 OK ✓ |
+| `http://test.my.brp/core/modules/system/tests/http.php` | tests exception !-https?\.php condition (s matches empty) | 200 OK ✓ |
+
+## Run Tests
+
+Execute the test script to verify all rules:
+```bash
+cd /home/alexey/projects/workspace-zed/test1/cms/drupal
+./test-drupal-rewriterules.sh
+```
+
+Expected results for Drupal tests (all should be **PASS ✓**):
+- Basic page routing via index.php: HTTP 200 + "Drupal Content Route" ✓
+- Hidden files (.htaccess, .htpasswd) blocked: HTTP 403 ✓
+- .well-known/robots.txt allowed: HTTP 200 ✓
+- install.php redirect to core: HTTP 301 ✓
+- rebuild.php redirect to core: HTTP 301 ✓
+- favicon.ico direct access (!-f): HTTP 200 ✓
+- Non-existing page routing to index.php: HTTP 200 ✓
+- Directory access (!-d): HTTP 200 ✓
+- Tests files https.php/http.php excluded from routing: HTTP 200 ✓
diff --git a/cms/drupal/core/install.php b/cms/drupal/core/install.php
new file mode 100644
index 0000000..020e85f
--- /dev/null
+++ b/cms/drupal/core/install.php
@@ -0,0 +1 @@
+# This is a test Drupal core/install.php file - should be protected by RewriteRule ^core/install\.php core/install.php?rewrite=ok [QSA,L]
diff --git a/cms/drupal/core/modules/system/tests/http.php b/cms/drupal/core/modules/system/tests/http.php
new file mode 100644
index 0000000..dc896e8
--- /dev/null
+++ b/cms/drupal/core/modules/system/tests/http.php
@@ -0,0 +1 @@
+# This is a test Drupal http.php in tests directory - should be excluded from index.php routing by RewriteCond %{REQUEST_URI} !/core/modules/system/tests/https?\.php
diff --git a/cms/drupal/core/modules/system/tests/https.php b/cms/drupal/core/modules/system/tests/https.php
new file mode 100644
index 0000000..0d8b08b
--- /dev/null
+++ b/cms/drupal/core/modules/system/tests/https.php
@@ -0,0 +1 @@
+# This is a test Drupal https.php in tests directory - should be excluded from index.php routing by RewriteCond %{REQUEST_URI} !/core/modules/system/tests/https?\.php
diff --git a/cms/drupal/core/rebuild.php b/cms/drupal/core/rebuild.php
new file mode 100644
index 0000000..8dd8cef
--- /dev/null
+++ b/cms/drupal/core/rebuild.php
@@ -0,0 +1 @@
+# This is a test Drupal core/rebuild.php file - should be protected by RewriteRule ^core/rebuild\.php core/rebuild.php?rewrite=ok [QSA,L]
diff --git a/cms/drupal/favicon.ico b/cms/drupal/favicon.ico
new file mode 100644
index 0000000..8ba1ca3
--- /dev/null
+++ b/cms/drupal/favicon.ico
@@ -0,0 +1,2 @@
+# This is a placeholder for Drupal test favicon.ico
+# Real favicon would be an image file, but we use text for testing
diff --git a/cms/drupal/index.php b/cms/drupal/index.php
new file mode 100644
index 0000000..d4e6431
--- /dev/null
+++ b/cms/drupal/index.php
@@ -0,0 +1,15 @@
+<?php
+/**
+ * Drupal - index.php (Test version)
+ * This file handles routing for non-existing files/directories
+ */
+
+// Simulated Drupal response
+echo "<html><head><title>Drupal Test Site</title></head><body>";
+echo "<h1>Drupal Content Route</h1>";
+echo "<p>This page is served by index.php via RewriteRule.</p>";
+echo "<div class='drupal-config'>Drupal Configuration Loaded</div>";
+echo "</body></html>";
+
+// Exit
+exit;
diff --git a/cms/drupal/nginx.conf b/cms/drupal/nginx.conf
new file mode 100644
index 0000000..9138219
--- /dev/null
+++ b/cms/drupal/nginx.conf
@@ -0,0 +1,159 @@
+
+load_module modules/ngx_http_apache_rewrite_module.so;
+worker_processes  1;
+
+error_log  logs/error.log  debug;
+
+events {
+    worker_connections  1024;
+}
+
+
+http {
+    include       mime.types;
+    default_type  application/octet-stream;
+
+    sendfile        on;
+
+    keepalive_timeout  65;
+
+
+    server {
+        listen       8081;
+        server_name  localhost;
+
+
+        location / {
+            root   html;
+            index  index.html index.htm;
+        }
+
+        error_page   500 502 503 504  /50x.html;
+        location = /50x.html {
+            root   html;
+        }
+
+    }
+
+    server {
+        listen 8081;
+        server_name example1.com;
+
+        root /sites/site1;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+
+        location / {
+            RewriteEngine On;
+        }
+
+    }
+
+    server {
+        listen 8081;
+        server_name example2.com;
+
+        root /sites/site2;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock;
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example3.com;
+
+        root /sites/site3;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example4.com;
+
+        root /sites/site4;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example5.com;
+
+        root /sites/site5;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+}
diff --git a/cms/drupal/site5.conf b/cms/drupal/site5.conf
new file mode 100644
index 0000000..a824b5a
--- /dev/null
+++ b/cms/drupal/site5.conf
@@ -0,0 +1,20 @@
+<VirtualHost *:80>
+    DocumentRoot "/sites/site5"
+    ServerName example5.com
+    ErrorLog logs/site5.log
+
+    DirectoryIndex index.php
+
+    <Directory /sites/site5>
+        Options +Indexes +FollowSymLinks
+        AllowOverride All
+        Require all granted
+    </Directory>
+     <FilesMatch "^\.htaccess$">
+        Require all granted
+    </FilesMatch>
+    <FilesMatch \.php$>
+	    SetHandler "proxy:unix:/run/php-fpm/www.sock|fcgi://localhost"
+    </FilesMatch>
+
+</VirtualHost>
diff --git a/cms/drupal/sites/all/default/settings.php.dummy/.gitkeep b/cms/drupal/sites/all/default/settings.php.dummy/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/cms/drupal/somedir/.gitkeep b/cms/drupal/somedir/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/cms/drupal/somedir/index.php b/cms/drupal/somedir/index.php
new file mode 100644
index 0000000..d96673c
--- /dev/null
+++ b/cms/drupal/somedir/index.php
@@ -0,0 +1,3 @@
+<?php
+
+echo "Ok";
diff --git a/cms/drupal/test-drupal-rewriterules.sh b/cms/drupal/test-drupal-rewriterules.sh
new file mode 100755
index 0000000..10ca63f
--- /dev/null
+++ b/cms/drupal/test-drupal-rewriterules.sh
@@ -0,0 +1,182 @@
+#!/bin/bash
+
+# ============================================
+# Drupal .htaccess Rules Test Script
+# ============================================
+# This script tests each rule from cms/drupal/.htaccess
+# Assumption: Site root is mapped to /home/alexey/projects/workspace-zed/test1/cms/drupal
+# Domain: test.my.brp
+# ============================================
+
+BASE_URL="http://test.my.brp"
+
+echo "=============================================="
+echo "Drupal .htaccess Rules Test Suite"
+echo "=============================================="
+echo ""
+
+# Function to test a rule and report result (status only)
+test_rule() {
+    local description="$1"
+    local url="$2"
+    local expected_status="$3"  # e.g., 403, 404, 200, 301
+
+    echo "--- Test: $description ---"
+    response=$(curl -s -o /dev/null -w "%{http_code}" "$url")
+
+    if [ "$response" = "$expected_status" ]; then
+        echo "✓ PASS (HTTP $response)"
+    else
+        echo "✗ FAIL (Expected: HTTP $expected_status, Got: HTTP $response)"
+    fi
+    echo ""
+}
+
+# Function to test a rule and verify content contains expected string
+test_rule_content() {
+    local description="$1"
+    local url="$2"
+    local headers="$3"  # Optional: additional curl -H header flags (can be empty)
+    local expected_status="$4"  # e.g., 403, 404, 200, 301
+    local expected_content="$5"  # Expected substring in response body
+
+    echo "--- Test: $description ---"
+
+    if [ -n "$headers" ]; then
+        response=$(curl -s -H "$headers" "$url")
+        http_code=$(curl -s -H "$headers" -o /dev/null -w "%{http_code}" "$url")
+    else
+        response=$(curl -s "$url")
+        http_code=$(curl -s -o /dev/null -w "%{http_code}" "$url")
+    fi
+
+    # Check status code
+    if [ "$http_code" != "$expected_status" ]; then
+        echo "✗ FAIL (Status: HTTP $http_code, Expected: HTTP $expected_status)"
+        return 1
+    fi
+
+    # Check content contains expected substring
+    if [[ "$response" == *"$expected_content"* ]]; then
+        echo "✓ PASS (HTTP $http_code, Content matches '$expected_content')"
+    else
+        echo "✗ FAIL (Content missing: '$expected_content') - Response:"
+        echo "$response" | head -5
+    fi
+    echo ""
+}
+
+echo "=============================================="
+echo "1. RewriteEngine Activation"
+echo "=============================================="
+# Test basic routing through index.php (proves RewriteEngine is active)
+test_rule_content "Basic page routing via index.php" \
+    "$BASE_URL/normal-page/" \
+    "" \
+    "200" \
+    "Drupal Content Route"
+
+echo ""
+echo "=============================================="
+echo "2. Protocol Variables (protossl)"
+echo "============================================}"
+# Test HTTPS protocol detection - since we use http://, HTTPS should be off
+test_rule_content "HTTP request without HTTPS (protocol detection)" \
+    "$BASE_URL/normal-page/" \
+    "" \
+    "200" \
+    "Drupal Content Route"
+
+echo ""
+echo "=============================================="
+echo "3. HTTP Authorization Header Passing"
+echo "=============================================="
+# Test that Authorization header is properly handled by Drupal REST API
+test_rule_content "Drupal handles Authorization header (API request)" \
+    "$BASE_URL/rest/api/v1" \
+    "Authorization: Bearer token_abc123" \
+    "200" \
+    "Drupal Content Route"
+
+echo ""
+echo "=============================================="
+echo "4. Hidden Files/Patterns Protection Rule"
+echo "=============================================="
+# Test hidden files blocked by RewriteRule "/\.|^\.(?!well-known/)" - [F]
+test_rule "Block .htaccess hidden file (pattern \.)" \
+    "$BASE_URL/.htaccess" \
+    "403"
+
+test_rule "Block .htpasswd hidden file (pattern \.)" \
+    "$BASE_URL/.htpasswd" \
+    "403"
+
+test_rule_content "Allow .well-known/robots.txt (exception for well-known)" \
+    "$BASE_URL/.well-known/robots.txt" \
+    "" \
+    "200" \
+    "User-agent:"
+
+echo ""
+echo "=============================================="
+echo "5. Core install/rebuild.php Protection Rules"
+echo "============================================}"
+# Test install.php protection - should route to core/install.php with rewrite=ok parameter
+test_rule "Core install.php protected routing" \
+    "$BASE_URL/install.php" \
+    "301"
+
+# Test rebuild.php protection - similar redirect pattern
+test_rule "Core rebuild.php protected routing" \
+    "$BASE_URL/rebuild.php" \
+    "301"
+
+echo ""
+echo "=============================================="
+echo "6. Drupal Core Files Routing Rules"
+echo "============================================}"
+# Test existing file access (!-f condition passes) - should return 200 OK without routing to index.php
+test_rule_content "Existing favicon.ico access (!-f condition)" \
+    "$BASE_URL/favicon.ico" \
+    "" \
+    "200" \
+    "This is a placeholder for Drupal test favicon.ico"
+
+echo ""
+echo "=============================================="
+echo "7. Main Drupal Routing Rules"
+echo "============================================}"
+# Test non-existing file routing through index.php (main routing) - !-f AND !-d pass
+test_rule_content "Non-existing page routing (routes to index.php)" \
+    "$BASE_URL/nonexistent-page/" \
+    "" \
+    "200" \
+    "Drupal Content Route"
+
+# Test existing directory access (!-d condition passes) - should return 200 OK
+test_rule "Existing directory access (somedir/)" \
+    "$BASE_URL/somedir/" \
+    "403"
+
+echo ""
+echo "=============================================="
+echo "8. Core Modules Tests Files Exceptions"
+echo "============================================}"
+# Test https.php in tests directory - should NOT route to index.php (excluded by RewriteCond)
+test_rule_content "Core modules/tests/https.php excluded from routing (!-php condition)" \
+    "$BASE_URL/core/modules/system/tests/https.php" \
+    "" \
+    "200" \
+    "# This is a test Drupal https.php in tests directory"
+
+# Test http.php in tests directory - same exclusion applies (s for https? regex)
+test_rule_content "Core modules/tests/http.php excluded from routing" \
+    "$BASE_URL/core/modules/system/tests/http.php" \
+    "" \
+    "200" \
+    "# This is a test Drupal http.php in tests directory"
+
+echo ""
+echo "=============================================="
+echo "Test Suite Complete"
+echo "=============================================="
diff --git a/cms/grav/.htaccess b/cms/grav/.htaccess
new file mode 100644
index 0000000..514d05e
--- /dev/null
+++ b/cms/grav/.htaccess
@@ -0,0 +1,74 @@
+RewriteEngine On
+
+# ============================================
+# 1. Security Rules - Test malicious patterns
+# ============================================
+
+# Detect template injection (Mustache, Twig syntax)
+RewriteCond %{REQUEST_URI} ({{|}}|{%|%}) [OR]
+RewriteCond %{QUERY_STRING} ({{|}}|{%25|%25}) [OR]
+
+# Base64 encoded payloads in query string
+RewriteCond %{QUERY_STRING} base64_encode[^(]*\([^)]*\) [OR]
+
+# Script injection patterns (HTML entities decoded)
+RewriteCond %{QUERY_STRING} (<|%3C)([^s]*s)+cript.*(>|%3E) [NC,OR]
+
+# GLOBALS exploitation attempt
+RewriteCond %{QUERY_STRING} GLOBALS(=|\[|\%[0-9A-Z]{0,2}) [OR]
+
+# _REQUEST manipulation (PHP superglobal abuse)
+RewriteCond %{QUERY_STRING} _REQUEST(=|\[|\%[0-9A-Z]{0,2})
+
+# Block malicious requests with 403 Forbidden
+RewriteRule .* index.php [F]
+
+# ============================================
+# 2. Grav CMS Core Routing Rules
+# ============================================
+
+# Prevent rewriting to index.php if already there
+RewriteCond %{REQUEST_URI} !^/index\.php
+
+# Allow access to existing files
+RewriteCond %{REQUEST_FILENAME} !-f
+
+# Allow access to existing directories
+RewriteCond %{REQUEST_FILENAME} !-d
+
+# Route everything else through Grav's index.php
+RewriteRule .* index.php [L]
+
+# ============================================
+# 3. Sensitive Directory Protection
+# ============================================
+
+# Block system, cache, logs, backups folders
+RewriteRule ^(\.git|cache|bin|logs|backup|webserver-configs|tests)/(.*) error [F]
+
+# Block system and vendor directories (prevent access to .txt/.xml files)
+RewriteRule ^(system|vendor)/(.*)\.(txt|xml|md|html|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
+
+# Block user directory access to configuration and content files
+RewriteRule ^(user)/(.*)\.(txt|md|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
+
+# ============================================
+# 4. File Extension Protection
+# ============================================
+
+# Block raw .md file access (content source files)
+RewriteRule \.md$ error [F]
+
+# ============================================
+# 5. Hidden Files/Directories Protection
+# ============================================
+
+# Block hidden files except well-known/robots.txt directories
+RewriteRule (^|/)\.(?!well-known) - [F]
+
+# ============================================
+# 6. Critical Configuration File Protection
+# ============================================
+
+# Block sensitive configuration and documentation files
+RewriteRule ^(LICENSE\.txt|composer\.lock|composer\.json|\.htaccess)$ error [F]
diff --git a/cms/grav/.htaccess.test b/cms/grav/.htaccess.test
new file mode 100644
index 0000000..1d37b0d
--- /dev/null
+++ b/cms/grav/.htaccess.test
@@ -0,0 +1 @@
+This is a .htaccess file - should be blocked by RewriteRule ^(LICENSE\.txt|composer\.lock|composer\.json|\.htaccess)$ error [F]
diff --git a/cms/grav/.htpasswd b/cms/grav/.htpasswd
new file mode 100644
index 0000000..cf0fc76
--- /dev/null
+++ b/cms/grav/.htpasswd
@@ -0,0 +1 @@
+This is a hidden .htpasswd file - should be blocked by RewriteRule (^|/)\.(?!well-known) - [F]
diff --git a/cms/grav/.well-known/robots.txt b/cms/grav/.well-known/robots.txt
new file mode 100644
index 0000000..d852aeb
--- /dev/null
+++ b/cms/grav/.well-known/robots.txt
@@ -0,0 +1 @@
+Robots.txt file - should be ALLOWED because it matches (.well-known) exception in RewriteRule (^|/)\.(?!well-known) - [F]
diff --git a/cms/grav/LICENSE.txt b/cms/grav/LICENSE.txt
new file mode 100644
index 0000000..31fd571
--- /dev/null
+++ b/cms/grav/LICENSE.txt
@@ -0,0 +1 @@
+This is a LICENSE.txt file - should be blocked by RewriteRule ^(LICENSE\.txt|composer\.lock|composer\.json|\.htaccess)$ error [F]
diff --git a/cms/grav/README.md b/cms/grav/README.md
new file mode 100644
index 0000000..ec0a223
--- /dev/null
+++ b/cms/grav/README.md
@@ -0,0 +1,119 @@
+# Grav CMS Test Structure - Updated
+
+## Directory Layout Overview
+
+```
+/test1/cms/grav/
+├── .git/              - Git folder tests (blocked)
+│   └── secret.txt
+├── .well-known/       - Well-known directory (allowed exception)
+│   └── robots.txt
+├── .htaccess          - Main Apache rules configuration
+├── .htpasswd          - Hidden file (blocked by Rule 5)
+├── bin/               - Bin folder tests (blocked)
+│   └── helper.php
+├── backup/            - Backup folder tests (blocked)
+│   └── archive.zip
+├── cache/             - Cache folder tests (blocked)
+│   └── test.txt
+├── composer.json      - Config file protection (blocked)
+├── composer.lock      - Config file protection (blocked)
+├── existing.jpg       - Existing file for routing test (200 OK)
+├── index.php          - Grav CMS entry point - routes non-existing files
+│                      - Returns: "Grav CMS Content Route" page
+├── LICENSE.txt        - Config file protection (blocked)
+├── logs/              - Logs folder tests (blocked)
+│   └── app.log
+├── normal-page.md     - Normal Grav CMS page (routes through index.php)
+├── README.md          - This documentation file
+├── somedir/           - Empty directory for routing test (200 OK)
+├── system/            - System folder tests (blocked extensions)
+│   └── config.xml
+├── vendor/            - Vendor folder tests (blocked extensions)
+│   └── module.txt
+├── user/              - User folder tests (blocked extensions)
+│   ├── test.txt
+│   ├── data.json
+│   ├── template.twig
+│   ├── script.sh
+│   ├── module.php
+│   ├── config.yml
+│   └── settings.yaml
+├── webserver-configs/ - Webserver configs folder tests (blocked)
+│   └── nginx.conf
+├── tests/             - Tests folder tests (blocked)
+│   └── unit-test.php
+├── test-mustache.php  - Security: Mustache template injection pattern
+├── twig-test.html     - Security: Twig syntax injection pattern
+├── test-rewriterules.sh - Bash script to test all rules using curl
+└── README.md          - Documentation
+```
+
+## Updated Test Script Features
+
+### New Content Verification Function
+
+The script now includes a `test_rule_content()` function that:
+1. Checks HTTP status code matches expected value
+2. Verifies response body contains expected content string
+
+**Example usage:**
+```bash
+test_rule_content "Normal page routing via index.php" \
+    "$BASE_URL/normal-page/" \
+    "200" \
+    "Grav CMS Content Route"
+```
+
+This tests that:
+- URL `/home/alexey/projects/workspace-zed/test1/cms/grav/normal-page/` (non-existing file) 
+- Returns HTTP 200 status (routed through index.php via Rule 2)
+- Response body contains "Grav CMS Content Route" text from index.php
+
+## Test Coverage Summary
+
+### 1. Security Rules - Malicious Patterns ✓
+- Template injection: `{{ }}`, `{% %}` in URI/Query String → **403**
+- Base64 payloads: `base64_encode()` pattern → **403**
+- Script injection: `<script>` or `%3C` encoded → **403**
+- GLOBALS exploitation: `GLOBALS[` pattern → **403**
+- _REQUEST manipulation: `_REQUEST[` pattern → **403**
+
+### 2. Core Routing Rules ✓ (Updated)
+- Non-existing file routes to index.php → **200** + content check
+- Existing file access → **200**
+- Existing directory access → **200**
+
+### 3. Sensitive Directory Protection ✓
+- Blocks: `.git`, `cache`, `bin`, `logs`, `backup` folders → **403**
+- Blocks system/vendor with sensitive extensions (`.txt`, `.xml`) → **403**
+
+### 4. File Extension Protection ✓
+- Blocks raw `.md` files → **403**
+
+### 5. Hidden Files/Directories Protection ✓
+- Blocks hidden files except `.well-known` → **403** / **200**
+
+### 6. Critical Configuration File Protection ✓
+- Blocks: `LICENSE.txt`, `composer.lock`, `composer.json`, `.htaccess` → **403**
+
+## Run Tests
+
+Execute the test script to verify all rules:
+```bash
+cd /home/alexey/projects/workspace-zed/test1/cms/grav
+./test-rewriterules.sh
+```
+
+Expected results for security tests (all should be **PASS ✓**):
+- Template injection: HTTP 403 ✓
+- Twig injection: HTTP 403 ✓
+- Base64 payload: HTTP 403 ✓
+- Script injection: HTTP 403 ✓
+- GLOBALS manipulation: HTTP 403 ✓
+- _REQUEST manipulation: HTTP 403 ✓
+
+Expected results for routing tests (should be **PASS ✓**):
+- Normal page routing: HTTP 200 + content "Grav CMS Content Route" ✓
+- Existing file access: HTTP 200 ✓
+- Directory access: HTTP 200 ✓
diff --git a/cms/grav/backup/archive.zip b/cms/grav/backup/archive.zip
new file mode 100644
index 0000000..b70c96f
--- /dev/null
+++ b/cms/grav/backup/archive.zip
@@ -0,0 +1 @@
+Backup archive.zip file - should be blocked by RewriteRule ^(\.git|cache|bin|logs|backup|webserver-configs|tests)/(.*) error [F]
diff --git a/cms/grav/bin/helper.php b/cms/grav/bin/helper.php
new file mode 100644
index 0000000..3d9dfb3
--- /dev/null
+++ b/cms/grav/bin/helper.php
@@ -0,0 +1 @@
+Bin helper.php file - should be blocked by RewriteRule ^(\.git|cache|bin|logs|backup|webserver-configs|tests)/(.*) error [F]
diff --git a/cms/grav/cache/test.txt b/cms/grav/cache/test.txt
new file mode 100644
index 0000000..450e4c8
--- /dev/null
+++ b/cms/grav/cache/test.txt
@@ -0,0 +1 @@
+Cache test.txt file - should be blocked by RewriteRule ^(\.git|cache|bin|logs|backup|webserver-configs|tests)/(.*) error [F]
diff --git a/cms/grav/composer.json b/cms/grav/composer.json
new file mode 100644
index 0000000..c2985fc
--- /dev/null
+++ b/cms/grav/composer.json
@@ -0,0 +1 @@
+{\"name\": \"test/my-site\", \"description\": \"Test Composer file\"}
diff --git a/cms/grav/composer.lock b/cms/grav/composer.lock
new file mode 100644
index 0000000..e118e40
--- /dev/null
+++ b/cms/grav/composer.lock
@@ -0,0 +1 @@
+This is a composer.lock file - should be blocked by RewriteRule ^(LICENSE\.txt|composer\.lock|composer\.json|\.htaccess)$ error [F]
diff --git a/cms/grav/existing.jpg b/cms/grav/existing.jpg
new file mode 100644
index 0000000..e69de29
diff --git a/cms/grav/index.php b/cms/grav/index.php
new file mode 100644
index 0000000..d2238cc
--- /dev/null
+++ b/cms/grav/index.php
@@ -0,0 +1,15 @@
+<?php
+/**
+ * Grav CMS - index.php (Test version)
+ * This file handles routing for non-existing files/directories
+ */
+
+// Simulated Grav CMS response
+echo "<html><head><title>Grav CMS Test Site</title></head><body>";
+echo "<h1>Grav CMS Content Route</h1>";
+echo "<p>This page is served by index.php via RewriteRule.</p>";
+echo "<div class='graviconfig'>Site Configuration Loaded</div>";
+echo "</body></html>";
+
+// Exit
+exit;
diff --git a/cms/grav/nginx.conf b/cms/grav/nginx.conf
new file mode 100644
index 0000000..9138219
--- /dev/null
+++ b/cms/grav/nginx.conf
@@ -0,0 +1,159 @@
+
+load_module modules/ngx_http_apache_rewrite_module.so;
+worker_processes  1;
+
+error_log  logs/error.log  debug;
+
+events {
+    worker_connections  1024;
+}
+
+
+http {
+    include       mime.types;
+    default_type  application/octet-stream;
+
+    sendfile        on;
+
+    keepalive_timeout  65;
+
+
+    server {
+        listen       8081;
+        server_name  localhost;
+
+
+        location / {
+            root   html;
+            index  index.html index.htm;
+        }
+
+        error_page   500 502 503 504  /50x.html;
+        location = /50x.html {
+            root   html;
+        }
+
+    }
+
+    server {
+        listen 8081;
+        server_name example1.com;
+
+        root /sites/site1;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+
+        location / {
+            RewriteEngine On;
+        }
+
+    }
+
+    server {
+        listen 8081;
+        server_name example2.com;
+
+        root /sites/site2;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock;
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example3.com;
+
+        root /sites/site3;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example4.com;
+
+        root /sites/site4;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example5.com;
+
+        root /sites/site5;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+}
diff --git a/cms/grav/normal-page.md b/cms/grav/normal-page.md
new file mode 100644
index 0000000..d3b91db
--- /dev/null
+++ b/cms/grav/normal-page.md
@@ -0,0 +1 @@
+Normal Grav CMS page - should be routed through index.php
diff --git a/cms/grav/site2.conf b/cms/grav/site2.conf
new file mode 100644
index 0000000..9e900a5
--- /dev/null
+++ b/cms/grav/site2.conf
@@ -0,0 +1,14 @@
+<VirtualHost *:80>
+    DocumentRoot "/sites/site2"
+    ServerName example2.com
+
+    <Directory /sites/site2>
+        Options +Indexes +FollowSymLinks
+        AllowOverride All
+        Require all granted
+    </Directory>
+    <FilesMatch \.php$>
+	    SetHandler "proxy:unix:/run/php-fpm/www.sock|fcgi://localhost"
+    </FilesMatch>
+
+</VirtualHost>
diff --git a/cms/grav/somedir/.gitkeep b/cms/grav/somedir/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/cms/grav/system/config.xml b/cms/grav/system/config.xml
new file mode 100644
index 0000000..e8dba38
--- /dev/null
+++ b/cms/grav/system/config.xml
@@ -0,0 +1 @@
+System config.xml file - should be blocked by RewriteRule ^(system|vendor)/(.*)\.(txt|xml|md|html|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
diff --git a/cms/grav/test-mustache.php b/cms/grav/test-mustache.php
new file mode 100644
index 0000000..e4dda05
--- /dev/null
+++ b/cms/grav/test-mustache.php
@@ -0,0 +1 @@
+This is a Mustache template injection test file with {{ variable }} syntax
diff --git a/cms/grav/test-rewriterules.sh b/cms/grav/test-rewriterules.sh
new file mode 100755
index 0000000..3120474
--- /dev/null
+++ b/cms/grav/test-rewriterules.sh
@@ -0,0 +1,150 @@
+#!/bin/bash
+
+# ============================================
+# Grav CMS .htaccess Rules Test Script
+# ============================================
+# This script tests each rule from cms/grav/.htaccess
+# Domain: test.my.brp
+# ============================================
+
+BASE_URL="http://test.my.brp"
+
+echo "=============================================="
+echo "Grav CMS .htaccess Rules Test Suite"
+echo "=============================================="
+echo ""
+
+# Function to test a rule and report result (status only)
+test_rule() {
+    local description="$1"
+    local url="$2"
+    local expected_status="$3"  # e.g., 403, 404, 200
+
+    echo "--- Test: $description ---"
+    response=$(curl -s -o /dev/null -w "%{http_code}" "$url")
+
+    if [ "$response" = "$expected_status" ]; then
+        echo "✓ PASS (HTTP $response)"
+    else
+        echo "✗ FAIL (Expected: HTTP $expected_status, Got: HTTP $response)"
+    fi
+    echo ""
+}
+
+# Function to test a rule and verify content contains expected string
+test_rule_content() {
+    local description="$1"
+    local url="$2"
+    local expected_status="$3"  # e.g., 403, 404, 200
+    local expected_content="$4"  # Expected substring in response body
+
+    echo "--- Test: $description ---"
+    response=$(curl -s "$url")
+    http_code=$(curl -s -o /dev/null -w "%{http_code}" "$url")
+
+    # Check status code
+    if [ "$http_code" != "$expected_status" ]; then
+        echo "✗ FAIL (Status: HTTP $http_code, Expected: HTTP $expected_status)"
+        return 1
+    fi
+
+    # Check content contains expected substring
+    if [[ "$response" == *"$expected_content"* ]]; then
+        echo "✓ PASS (HTTP $http_code, Content matches '$expected_content')"
+    else
+        echo "✗ FAIL (Content missing: '$expected_content') - Response:"
+        echo "$response" | head -5
+    fi
+    echo ""
+}
+
+echo "=============================================="
+echo "1. Security Rules - Test malicious patterns"
+echo "=============================================="
+# Template injection via query string with {{ }} Mustache syntax
+test_rule "Template injection via query string ({{ }}" \
+    "$BASE_URL/test-mustache.php?\{\{config.secret\}\}" \
+    "403"
+
+# Base64 encoded payloads (base64_encode function call)
+test_rule "Base64 payload pattern" \
+    "$BASE_URL/test.php?data=base64_encode(some_secret)" \
+    "403"
+
+# Script injection (<script> or HTML entities %3C)
+test_rule "Script injection (encoded)" \
+    "$BASE_URL/search.html?q=%3Cscript%25alert(1)%3E" \
+    "403"
+
+# GLOBALS exploitation attempt
+test_rule "GLOBALS manipulation" \
+    "$BASE_URL/leak.php?GLOBALS\[secret\]=exploit" \
+    "403"
+
+# _REQUEST manipulation (PHP superglobal abuse)
+test_rule "_REQUEST manipulation" \
+    "$BASE_URL/attack.php?_REQUEST\[user\]=admin" \
+    "403"
+
+echo ""
+echo "=============================================="
+echo "2. Grav CMS Core Routing Rules"
+echo "=============================================="
+# Test normal page routing through index.php (non-existing file -> index.php)
+test_rule_content "Normal page routing via index.php" \
+    "$BASE_URL/normal-page/" \
+    "200" \
+    "Grav CMS Content Route"
+
+# Test existing file access - check status + content type/image
+test_rule "Existing file access (existing.jpg)" \
+    "$BASE_URL/existing.jpg" \
+    "200"
+
+# Test existing directory access
+test_rule "Existing directory access (somedir/)" \
+    "$BASE_URL/somedir/" \
+    "200"
+
+echo ""
+echo "=============================================="
+echo "3. Sensitive Directory Protection"
+echo "=============================================="
+# Block system, cache, logs, backups folders
+test_rule "Block .git folder" "$BASE_URL/.git/secret.txt" "403"
+test_rule "Block cache folder" "$BASE_URL/cache/test.txt" "403"
+test_rule "Block bin folder" "$BASE_URL/bin/helper.php" "403"
+test_rule "Block logs folder" "$BASE_URL/logs/app.log" "403"
+test_rule "Block backup folder" "$BASE_URL/backup/archive.zip" "403"
+
+# Block system and vendor directories with sensitive extensions
+test_rule "Block system config.xml" "$BASE_URL/system/config.xml" "403"
+test_rule "Block vendor module.txt" "$BASE_URL/vendor/module.txt" "403"
+
+echo ""
+echo "=============================================="
+echo "4. File Extension Protection"
+echo "=============================================="
+# Block raw .md file access (content source files)
+test_rule "Block raw .md file" "$BASE_URL/test.md" "403"
+
+echo ""
+echo "=============================================="
+echo "5. Hidden Files/Directories Protection"
+echo "=============================================="
+test_rule "Block hidden .htpasswd" "$BASE_URL/.htpasswd" "403"
+test_rule "Allow .well-known/robots.txt" "$BASE_URL/.well-known/robots.txt" "200"
+
+echo ""
+echo "=============================================="
+echo "6. Critical Configuration File Protection"
+echo "=============================================="
+test_rule "Block LICENSE.txt" "$BASE_URL/LICENSE.txt" "403"
+test_rule "Block composer.lock" "$BASE_URL/composer.lock" "403"
+test_rule "Block composer.json" "$BASE_URL/composer.json" "403"
+test_rule "Block .htaccess" "$BASE_URL/.htaccess" "403"
+
+echo ""
+echo "=============================================="
+echo "Test Suite Complete"
+echo "=============================================="
diff --git a/cms/grav/test.md b/cms/grav/test.md
new file mode 100644
index 0000000..69fce50
--- /dev/null
+++ b/cms/grav/test.md
@@ -0,0 +1 @@
+Test.md
diff --git a/cms/grav/tests/unit-test.php b/cms/grav/tests/unit-test.php
new file mode 100644
index 0000000..50fac55
--- /dev/null
+++ b/cms/grav/tests/unit-test.php
@@ -0,0 +1 @@
+Tests unit-test.php file - should be blocked by RewriteRule ^(\.git|cache|bin|logs|backup|webserver-configs|tests)/(.*) error [F]
diff --git a/cms/grav/twig-test.html b/cms/grav/twig-test.html
new file mode 100644
index 0000000..39bbee3
--- /dev/null
+++ b/cms/grav/twig-test.html
@@ -0,0 +1 @@
+This is a Twig template syntax test file with {% comment %} syntax
diff --git a/cms/grav/user/config.yml b/cms/grav/user/config.yml
new file mode 100644
index 0000000..2f9c988
--- /dev/null
+++ b/cms/grav/user/config.yml
@@ -0,0 +1 @@
+User config.yml file - should be blocked by RewriteRule ^(user)/(.*)\.(txt|md|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
diff --git a/cms/grav/user/data.json b/cms/grav/user/data.json
new file mode 100644
index 0000000..f08f430
--- /dev/null
+++ b/cms/grav/user/data.json
@@ -0,0 +1 @@
+User data.json file - should be blocked by RewriteRule ^(user)/(.*)\.(txt|md|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
diff --git a/cms/grav/user/module.php b/cms/grav/user/module.php
new file mode 100644
index 0000000..1f4dc0b
--- /dev/null
+++ b/cms/grav/user/module.php
@@ -0,0 +1 @@
+User module.php file - should be blocked by RewriteRule ^(user)/(.*)\.(txt|md|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
diff --git a/cms/grav/user/script.sh b/cms/grav/user/script.sh
new file mode 100644
index 0000000..042a517
--- /dev/null
+++ b/cms/grav/user/script.sh
@@ -0,0 +1 @@
+User script.sh file - should be blocked by RewriteRule ^(user)/(.*)\.(txt|md|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
diff --git a/cms/grav/user/settings.yaml b/cms/grav/user/settings.yaml
new file mode 100644
index 0000000..5282a87
--- /dev/null
+++ b/cms/grav/user/settings.yaml
@@ -0,0 +1 @@
+User settings.yaml file - should be blocked by RewriteRule ^(user)/(.*)\.(txt|md|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
diff --git a/cms/grav/user/template.twig b/cms/grav/user/template.twig
new file mode 100644
index 0000000..c486815
--- /dev/null
+++ b/cms/grav/user/template.twig
@@ -0,0 +1 @@
+User template.twig file - should be blocked by RewriteRule ^(user)/(.*)\.(txt|md|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
diff --git a/cms/grav/user/test.txt b/cms/grav/user/test.txt
new file mode 100644
index 0000000..574cdbf
--- /dev/null
+++ b/cms/grav/user/test.txt
@@ -0,0 +1 @@
+User test.txt file - should be blocked by RewriteRule ^(user)/(.*)\.(txt|md|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
diff --git a/cms/grav/vendor/module.txt b/cms/grav/vendor/module.txt
new file mode 100644
index 0000000..e12c973
--- /dev/null
+++ b/cms/grav/vendor/module.txt
@@ -0,0 +1 @@
+Vendor module.txt file - should be blocked by RewriteRule ^(system|vendor)/(.*)\.(txt|xml|md|html|json|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ error [F]
diff --git a/cms/grav/webserver-configs/nginx.conf b/cms/grav/webserver-configs/nginx.conf
new file mode 100644
index 0000000..d9afee7
--- /dev/null
+++ b/cms/grav/webserver-configs/nginx.conf
@@ -0,0 +1 @@
+Webserver configs nginx.conf file - should be blocked by RewriteRule ^(\.git|cache|bin|logs|backup|webserver-configs|tests)/(.*) error [F]
diff --git a/cms/joomla/.htaccess b/cms/joomla/.htaccess
new file mode 100644
index 0000000..5d67512
--- /dev/null
+++ b/cms/joomla/.htaccess
@@ -0,0 +1,16 @@
+RewriteEngine On
+RewriteCond %{QUERY_STRING} base64_encode[^(]*\([^)]*\) [OR]
+RewriteCond %{QUERY_STRING} (<|%3C)([^s]*s)+cript.*(>|%3E) [NC,OR]
+RewriteCond %{QUERY_STRING} GLOBALS(=|\[|\%[0-9A-Z]{0,2}) [OR]
+RewriteCond %{QUERY_STRING} _REQUEST(=|\[|\%[0-9A-Z]{0,2})
+RewriteRule .* index.php [F]
+RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+RewriteCond %{REQUEST_URI} ^/api/
+RewriteCond %{REQUEST_URI} !^/api/index\.php
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteRule .* api/index.php [L]
+RewriteCond %{REQUEST_URI} !^/index\.php
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteRule .* index.php [L]
diff --git a/cms/joomla/.well-known/robots.txt b/cms/joomla/.well-known/robots.txt
new file mode 100644
index 0000000..f93498a
--- /dev/null
+++ b/cms/joomla/.well-known/robots.txt
@@ -0,0 +1,6 @@
+# This is a well-known robots.txt file for Joomla testing
+# Should be accessible via RewriteRule /api/index.php [L] or standard routing
+
+User-agent: *
+Disallow: /administrator/
+Allow: /
diff --git a/cms/joomla/README.md b/cms/joomla/README.md
new file mode 100644
index 0000000..6182f60
--- /dev/null
+++ b/cms/joomla/README.md
@@ -0,0 +1,153 @@
+# Joomla .htaccess Test Structure
+
+## Directory Layout Overview
+
+```
+/test1/cms/joomla/
+├── api/                      - API directory tests
+│   └── index.php             - Joomla API entry point (routes /api/ requests)
+│                               - Returns: "Joomla API Configuration Loaded"
+├── .well-known/              - Well-known directory
+│   └── robots.txt            - Allowed file via exception
+├── base64-test.php           - Security test for base64_encode pattern detection
+├── globals-test.php          - Security test for GLOBALS exploitation pattern
+├── request-test.php          - Security test for _REQUEST manipulation pattern
+├── script-test.php           - Security test for script injection pattern
+├── index.php                 - Joomla main entry point (routes non-existing files)
+│                                - Returns: "Joomla Content Route" page
+├── somedir/                  - Directory for testing !-d condition (200 OK)
+├── test-joomla-rewriterules.sh - Bash script to test all rules using curl
+└── README.md                 - This documentation file
+```
+
+## Apache Rules Explained - Joomla
+
+### 1. Base64 Encoded Payload Detection Rule
+
+```apache
+RewriteCond %{QUERY_STRING} base64_encode[^(]*\([^)]*\) [OR]
+```
+
+**Что делает:** Detects Base64 encoded payloads in query string (function call pattern)
+**Зачем нужно:** Защита от Base64-encoded malicious code injection attacks
+- Pattern: `base64_encode(...)` - detect function calls that encode data
+
+### 2. Script Injection Pattern Detection Rule
+
+```apache
+RewriteCond %{QUERY_STRING} (<|%3C)([^s]*s)+cript.*(>|%3E) [NC,OR]
+```
+
+**Что делает:** Detects script injection patterns (HTML entities decoded)
+**Зачем нужно:** Защита от XSS attacks через URL parameters
+- Pattern: `<script>...` or `%3Cscript%3E` - detect HTML script tags
+- `[NC]` - case-insensitive matching
+
+### 3. GLOBALS Exploitation Detection Rule
+
+```apache
+RewriteCond %{QUERY_STRING} GLOBALS(=|\[|\%[0-9A-Z]{0,2}) [OR]
+```
+
+**Что делает:** Detects GLOBALS exploitation attempt in query string
+**Зачем нужно:** Защита от PHP superglobal abuse attacks
+- Pattern: `GLOBALS=` or `GLOBALS[` - detect attempts to manipulate global variables
+
+### 4. _REQUEST Manipulation Detection Rule
+
+```apache
+RewriteCond %{QUERY_STRING} _REQUEST(=|\[|\%[0-9A-Z]{0,2})
+```
+
+**Что делает:** Detects _REQUEST manipulation (PHP superglobal abuse)
+**Зачем нужно:** Защита от PHP superglobal exploitation attacks
+- Pattern: `_REQUEST=` or `_REQUEST[` - detect attempts to manipulate $_REQUEST array
+
+### 5. Malicious Requests Blocked with [F] Flag
+
+```apache
+RewriteRule .* index.php [F]
+```
+
+**Что делает:** Blocks malicious requests with 403 Forbidden
+**Зачем нужно:** Все запросы, которые прошли security checks выше - блокируются
+
+### 6. HTTP Authorization Header Passing Rule
+
+```apache
+RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+```
+
+**Что делает:** Копирует Authorization header в переменную HTTP_AUTHORIZATION для PHP
+**Зачем нужно:** Joomla REST API требует эту переменную для аутентификации
+
+### 7. Joomla API Routing Rule (/api/)
+
+```apache
+RewriteCond %{REQUEST_URI} ^/api/
+RewriteCond %{REQUEST_URI} !^/api/index\.php
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteRule .* api/index.php [L]
+```
+
+**Что делает:** Маршрутизирует запросы в `/api/` через `api/index.php` (если не существующий файл/directory)
+**Зачем нужно:** Joomla REST API routing - отдельная точка входа для API endpoints
+- **Исключение:** Если запрос прямо на /api/index.php - пропускаем (не переписываем)
+
+### 8. Main Joomla Routing Rule (/index.php exclusion)
+
+```apache
+RewriteCond %{REQUEST_URI} !^/index\.php
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteRule .* index.php [L]
+```
+
+**Что делает:** Маршрутизирует все запросы через main `index.php` (!-f AND !-d pass)
+**Зачем нужно:** Joomla "clean URLs" routing (похоже на WordPress/Drupal)
+- **Исключение:** Не переписывает прямой доступ к /index.php
+
+## Test Script Features
+
+The script includes test functions:
+1. **test_rule()** - checks HTTP status code only
+2. **test_rule_content()** - checks both status AND response body content
+
+## Security Pattern Testing Scenarios
+
+### Query String Pattern Detection
+
+| URL | Правило | Ожидаемый результат |
+|-----|---------|---------------------|
+| `http://test.my.brp/base64-test.php?data=base64_encode(secret)` | base64_encode pattern detection → 403 ✓ |
+| `http://test.my.brp/script-test.php?q=%3Cscript%3Ealert(1)%3E` | script injection pattern → 403 ✓ |
+| `http://test.my.brp/globals-test.php?GLOBALS[user]=admin` | GLOBALS exploitation → 403 ✓ |
+| `http://test.my.brp/request-test.php?_REQUEST[config]=true` | _REQUEST manipulation → 403 ✓ |
+
+### API vs Main Routing
+
+| URL | Правило | Ожидаемый результат |
+|-----|---------|---------------------|
+| `http://test.my.brp/api/` | api/index.php routing (!-f, !-d pass) → api/index.php ✓ |
+| `http://test.my.brp/api/index.php` | Direct access (excluded from api routing) → 200 OK ✓ |
+| `http://test.my.brp/nonexistent-page/` | Main index.php routing (!-f, !-d pass) → main index.php ✓ |
+
+## Run Tests
+
+Execute the test script to verify all rules:
+```bash
+cd /home/alexey/projects/workspace-zed/test1/cms/joomla
+./test-joomla-rewriterules.sh
+```
+
+Expected results for Joomla tests (all should be **PASS ✓**):
+- Base64 encoded payload blocked: HTTP 403 ✓
+- Script injection blocked: HTTP 403 ✓
+- GLOBALS exploitation blocked: HTTP 403 ✓
+- _REQUEST manipulation blocked: HTTP 403 ✓
+- Authorization header handling: HTTP 200 + "Joomla Content Route" ✓
+- API index.php routing: HTTP 200 + "Joomla API Configuration Loaded" ✓
+- Direct /api/index.php file access: HTTP 200 OK ✓
+- Main index.php routing (non-existing page): HTTP 200 + "Joomla Content Route" ✓
+- Directory access (!-d): HTTP 200 OK ✓
diff --git a/cms/joomla/api/index.php b/cms/joomla/api/index.php
new file mode 100644
index 0000000..48704bb
--- /dev/null
+++ b/cms/joomla/api/index.php
@@ -0,0 +1,56 @@
+
+<?php
+/**
+ * WordPress REST API Mock (Test version)
+ * This file checks if Authorization header is properly passed from mod_rewrite
+ */
+
+// Check if Authorization header was received
+$auth_header = "";
+if (isset($_SERVER["HTTP_AUTHORIZATION"])) {
+    $auth_header = $_SERVER["HTTP_AUTHORIZATION"];
+} else {
+    // Also check for rewritten env var
+    $auth_env = getenv("HTTP_AUTHORIZATION");
+    if ($auth_env !== false && $auth_env !== "") {
+        $auth_header = $auth_env;
+    }
+}
+
+// Set response headers
+header("Content-Type: application/json; charset=UTF-8");
+
+if ($auth_header === "secret_token_123") {
+    // SUCCESS - Authorization header was properly passed through mod_rewrite
+
+    echo json_encode(
+        [
+            "status" => "success",
+            "message" => "Authorization verified",
+            "token_verified" => true,
+            "wordpress_config_loaded" => true,
+            "received_auth_header" => $auth_header,
+        ],
+        JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES,
+    );
+} else {
+    // FAIL - Authorization header was not passed through mod_rewrite
+
+    http_response_code(401);
+
+    echo json_encode(
+        [
+            "status" => "error",
+            "message" => "unauth",
+            "expected" => "Bearer secret_token_123",
+            "received" => $auth_header ?: "(not set)",
+            "test_failed" => true,
+            "hint" =>
+                "mod_rewrite [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}] is NOT passing header to PHP",
+        ],
+        JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES,
+    );
+}
+
+exit();
+
diff --git a/cms/joomla/api/index.php.dummy b/cms/joomla/api/index.php.dummy
new file mode 100644
index 0000000..d8f454e
--- /dev/null
+++ b/cms/joomla/api/index.php.dummy
@@ -0,0 +1 @@
+# Joomla API test - should be allowed when accessed via /api/index.php (excluded from index.php routing)
diff --git a/cms/joomla/base64-test.php b/cms/joomla/base64-test.php
new file mode 100644
index 0000000..b91e904
--- /dev/null
+++ b/cms/joomla/base64-test.php
@@ -0,0 +1,2 @@
+# Joomla security test - base64_encode payload pattern
+# This file should be blocked when accessed with query string containing base64_encode[^(]*\([^)]*\)
diff --git a/cms/joomla/globals-test.php b/cms/joomla/globals-test.php
new file mode 100644
index 0000000..4805627
--- /dev/null
+++ b/cms/joomla/globals-test.php
@@ -0,0 +1,2 @@
+# Joomla security test - GLOBALS exploitation pattern
+# This file should be blocked when accessed with query string containing GLOBALS(=|\[|\%[0-9A-Z]{0,2})
diff --git a/cms/joomla/index.php b/cms/joomla/index.php
new file mode 100644
index 0000000..28f20cb
--- /dev/null
+++ b/cms/joomla/index.php
@@ -0,0 +1,15 @@
+<?php
+/**
+ * Joomla - index.php (Test version)
+ * This file handles routing for non-existing files/directories
+ */
+
+// Simulated Joomla response
+echo "<html><head><title>Joomla Test Site</title></head><body>";
+echo "<h1>Joomla Content Route</h1>";
+echo "<p>This page is served by index.php via RewriteRule.</p>";
+echo "<div class='joomla-config'>Joomla Configuration Loaded</div>";
+echo "</body></html>";
+
+// Exit
+exit;
diff --git a/cms/joomla/nginx.conf b/cms/joomla/nginx.conf
new file mode 100644
index 0000000..9138219
--- /dev/null
+++ b/cms/joomla/nginx.conf
@@ -0,0 +1,159 @@
+
+load_module modules/ngx_http_apache_rewrite_module.so;
+worker_processes  1;
+
+error_log  logs/error.log  debug;
+
+events {
+    worker_connections  1024;
+}
+
+
+http {
+    include       mime.types;
+    default_type  application/octet-stream;
+
+    sendfile        on;
+
+    keepalive_timeout  65;
+
+
+    server {
+        listen       8081;
+        server_name  localhost;
+
+
+        location / {
+            root   html;
+            index  index.html index.htm;
+        }
+
+        error_page   500 502 503 504  /50x.html;
+        location = /50x.html {
+            root   html;
+        }
+
+    }
+
+    server {
+        listen 8081;
+        server_name example1.com;
+
+        root /sites/site1;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+
+        location / {
+            RewriteEngine On;
+        }
+
+    }
+
+    server {
+        listen 8081;
+        server_name example2.com;
+
+        root /sites/site2;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock;
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example3.com;
+
+        root /sites/site3;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example4.com;
+
+        root /sites/site4;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example5.com;
+
+        root /sites/site5;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+}
diff --git a/cms/joomla/request-test.php b/cms/joomla/request-test.php
new file mode 100644
index 0000000..fa8ecbc
--- /dev/null
+++ b/cms/joomla/request-test.php
@@ -0,0 +1,2 @@
+# Joomla security test - _REQUEST manipulation pattern
+# This file should be blocked when accessed with query string containing _REQUEST(=|\[|\%[0-9A-Z]{0,2})
diff --git a/cms/joomla/script-test.php b/cms/joomla/script-test.php
new file mode 100644
index 0000000..8efa551
--- /dev/null
+++ b/cms/joomla/script-test.php
@@ -0,0 +1,2 @@
+# Joomla security test - script injection pattern
+# This file should be blocked when accessed with query string containing (<|%3C)([^s]*s)+cript.*(>|%3E)
diff --git a/cms/joomla/site4.conf b/cms/joomla/site4.conf
new file mode 100644
index 0000000..2b7ca41
--- /dev/null
+++ b/cms/joomla/site4.conf
@@ -0,0 +1,16 @@
+<VirtualHost *:80>
+    DocumentRoot "/sites/site4"
+    ServerName example4.com
+
+    DirectoryIndex index.php
+
+    <Directory /sites/site4>
+        Options +Indexes +FollowSymLinks
+        AllowOverride All
+        Require all granted
+    </Directory>
+    <FilesMatch \.php$>
+    	SetHandler "proxy:unix:/run/php-fpm/www.sock|fcgi://localhost"
+    </FilesMatch>
+
+</VirtualHost>
diff --git a/cms/joomla/test-joomla-rewriterules.sh b/cms/joomla/test-joomla-rewriterules.sh
new file mode 100755
index 0000000..30f7fa1
--- /dev/null
+++ b/cms/joomla/test-joomla-rewriterules.sh
@@ -0,0 +1,170 @@
+#!/bin/bash
+
+# ============================================
+# Joomla .htaccess Rules Test Script
+# ============================================
+# This script tests each rule from cms/joomla/.htaccess
+# Assumption: Site root is mapped to /home/alexey/projects/workspace-zed/test1/cms/joomla
+# Domain: test.my.brp
+# ============================================
+
+BASE_URL="http://test.my.brp"
+
+echo "=============================================="
+echo "Joomla .htaccess Rules Test Suite"
+echo "=============================================="
+echo ""
+
+# Function to test a rule and report result (status only)
+test_rule() {
+    local description="$1"
+    local url="$2"
+    local expected_status="$3"  # e.g., 403, 404, 200, 301
+
+    echo "--- Test: $description ---"
+    response=$(curl -s -o /dev/null -w "%{http_code}" "$url")
+
+    if [ "$response" = "$expected_status" ]; then
+        echo "✓ PASS (HTTP $response)"
+    else
+        echo "✗ FAIL (Expected: HTTP $expected_status, Got: HTTP $response)"
+    fi
+    echo ""
+}
+
+# Function to test a rule and verify content contains expected string
+test_rule_content() {
+    local description="$1"
+    local url="$2"
+    local headers="$3"  # Optional: additional curl -H header flags (can be empty)
+    local expected_status="$4"  # e.g., 403, 404, 200, 301
+    local expected_content="$5"  # Expected substring in response body
+
+    echo "--- Test: $description ---"
+
+    if [ -n "$headers" ]; then
+        response=$(curl -s -H "$headers" "$url")
+        http_code=$(curl -s -H "$headers" -o /dev/null -w "%{http_code}" "$url")
+    else
+        response=$(curl -s "$url")
+        http_code=$(curl -s -o /dev/null -w "%{http_code}" "$url")
+    fi
+
+    # Check status code
+    if [ "$http_code" != "$expected_status" ]; then
+        echo "✗ FAIL (Status: HTTP $http_code, Expected: HTTP $expected_status)"
+        return 1
+    fi
+
+    # Check content contains expected substring
+    if [[ "$response" == *"$expected_content"* ]]; then
+        echo "✓ PASS (HTTP $http_code, Content matches '$expected_content')"
+    else
+        echo "✗ FAIL (Content missing: '$expected_content') - Response:"
+        echo "$response" | head -5
+    fi
+    echo ""
+}
+
+echo "=============================================="
+echo "1. Base64 Encoded Payload Detection Rule"
+echo "=============================================="
+# Test base64_encode pattern detection in query string
+test_rule "Base64 encoded payload blocked (base64_encode function call)" \
+    "$BASE_URL/base64-test.php?data=base64_encode(secret_password)" \
+    "403"
+
+echo ""
+echo "=============================================="
+echo "2. Script Injection Pattern Detection Rule"
+echo "============================================}"
+# Test script injection pattern detection in query string (HTML entities)
+test_rule "Script injection blocked (script tag encoded)" \
+    "$BASE_URL/script-test.php?q=%3Cscript%3Ealert(1)%3E" \
+    "403"
+
+echo ""
+echo "=============================================="
+echo "3. GLOBALS Exploitation Detection Rule"
+echo "============================================}"
+# Test GLOBALS exploitation pattern detection in query string
+test_rule "GLOBALS exploitation blocked (GLOBALS[secret] pattern)" \
+    "$BASE_URL/globals-test.php?GLOBALS%5Buser%5D=admin" \
+    "403"
+
+echo ""
+echo "=============================================="
+echo "4. _REQUEST Manipulation Detection Rule"
+echo "============================================}"
+# Test _REQUEST manipulation pattern detection in query string
+test_rule "_REQUEST manipulation blocked (_REQUEST[config] pattern)" \
+    "$BASE_URL/request-test.php?_REQUEST%5Badmin%5D=true" \
+    "403"
+
+echo ""
+echo "=============================================="
+echo "5. HTTP Authorization Header Passing Rule"
+echo "============================================}"
+# Test that Authorization header is properly handled by Joomla REST API
+test_rule_content "Joomla handles Authorization header (API request)" \
+    "$BASE_URL/rest/api/v1" \
+    "Authorization: Bearer joomla_token_abc" \
+    "200" \
+    "Joomla Content Route"
+
+echo ""
+echo "=============================================="
+echo "6. Joomla API Routing Rule (/api/)"
+echo "============================================}"
+# Test /api/index.php routing - should route to api/index.php (!-f, !-d pass for non-existing files)
+test_rule_content "API index.php routing (routes to /api/index.php)" \
+    "$BASE_URL/api/" \
+    "Authorization: secret_token_123" \
+    "200" \
+    "\"status\": \"success\""
+
+# Additional test: verify token verification in response
+test_rule_content "Direct /api/index.php file access" \
+    "$BASE_URL/api/index.php" \
+    "" \
+    "401" \
+    "\"message\": \"unauth\""
+
+echo ""
+echo "=============================================="
+echo "7. Main Joomla Routing Rule (/index.php exclusion)"
+echo "============================================}"
+# Test that /api/index.php is NOT routed to main index.php (!^/api/index\.php passes)
+test_rule_content "/api/index.php excluded from main routing (direct file access)" \
+    "$BASE_URL/api/index.php" \
+    "" \
+    "200" \
+    "Joomla API Configuration Loaded"
+
+# Test non-existing file routing through main index.php (!-f AND !-d pass)
+test_rule_content "Non-existing page routing (routes to /index.php)" \
+    "$BASE_URL/nonexistent-page/" \
+    "" \
+    "200" \
+    "Joomla Content Route"
+
+# Test existing directory access (!-d condition passes) - should return 200 OK
+test_rule "Existing directory access (somedir/)" \
+    "$BASE_URL/somedir/" \
+    "200"
+
+echo ""
+echo "=============================================="
+echo "8. Joomla index.php reditercting"
+echo "============================================}"
+# Test that /api/index.php is NOT routed to main index.php (!^/api/index\.php passes)
+test_rule_content "/index.php/component/config?view=modules accessing" \
+    "$BASE_URL/index.php/component/config?view=modules" \
+    "" \
+    "200" \
+    "Joomla Content Route"
+
+echo ""
+echo "=============================================="
+echo "Test Suite Complete"
+echo "=============================================="
diff --git a/cms/simple/.htaccess b/cms/simple/.htaccess
new file mode 100644
index 0000000..885b558
--- /dev/null
+++ b/cms/simple/.htaccess
@@ -0,0 +1,73 @@
+# ============================================================
+#   .htaccess - Тесты Apache mod_rewrite для nginx
+# ============================================================
+# Этот файл содержит правила mod_rewrite для тестирования функционала
+# модуля ngx_http_apache_rewrite_module в nginx, аналогичного Apache mod_rewrite
+
+# ============================================================
+#   1. Перенаправление файлов с расширением .xmx на index.html
+# ============================================================
+# Правиство перенаправляет ВСЕ файлы заканчивающиеся на .xmx
+# на страницу index.html (внешнее перенаправление)
+
+RewriteEngine On
+RewriteRule \.xmx$ /index.html [R=301,L]
+
+# Тестирование:
+# - http://localhost/test/test.xmx → 301 redirect to /index.html
+# - http://localhost/test/subdir/file.xmx → 301 redirect to /index.html
+
+# ============================================================
+#   2. Блокировка доступа к stop.html (403 Forbidden)
+# ============================================================
+# Правиство запрещает доступ к файлу stop.html, возвращая ошибку 403
+
+RewriteCond %{REQUEST_FILENAME} stop.html$
+RewriteRule ^ - [F,L]
+
+# Тестирование:
+# - http://localhost/test/stop.html → 403 Forbidden (доступ запрещен)
+
+# ============================================================
+#   3. Внутреннее перенаправление redirect.html на show.html
+# ============================================================
+# Правиство скрывает redirect.html и показывает вместо него show.html
+# Это внутренняя переадресация (без изменения URL в браузере)
+
+RewriteRule ^redirect\.html$ show.html [L]
+
+# Тестирование:
+# - http://localhost/test/redirect.html → показывает содержимое show.html
+# - URL остается /test/redirect.html, но показывается content из show.html
+
+# ============================================================
+#   4. Перенаправление подкаталога subdir на index.html
+# ============================================================
+# При обращении к подкаталогу redirect его на главную страницу
+
+RewriteRule ^subdir/?$ /index.html [L]
+
+# Тестирование:
+# - http://localhost/test/subdir/ → показывает index.html
+
+# ============================================================
+#   5. Блокировка доступа ко всем .xmx файлам (кроме test.xmx)
+# ============================================================
+# Дополнительно блокируем все файлы с расширением xmx кроме test.xmx
+# Это демонстрирует условные правила с RewriteCond
+
+RewriteCond %{REQUEST_FILENAME} !test\.xmx$
+RewriteRule \.xmx$ - [F,L]
+
+# Примечание: это правило будет работать ПОСЛЕ первого правила перенаправления
+# поэтому test.xmx сначала перенаправляется на index.html, а затем блокируется
+
+# ============================================================
+#   6. Переопределение статуса ответа (403 Forbidden) для subdir
+# ============================================================
+# При обращении к подкаталогу возвращаем ошибку 403 вместо 200 OK
+
+#RewriteRule ^subdir/?$ - [F,L]
+
+# Примечание: это правило будет работать ПОСЛЕ правила 4, поэтому subdir
+# сначала будет переадресован на index.html, а затем заблокирован
diff --git a/cms/simple/README.md b/cms/simple/README.md
new file mode 100644
index 0000000..476118b
--- /dev/null
+++ b/cms/simple/README.md
@@ -0,0 +1,127 @@
+# Тесты Apache mod_rewrite для nginx
+
+## Обзор
+
+Этот каталог содержит тестовые файлы и правила `.htaccess` для проверки функционала модуля `ngx_http_apache_rewrite_module` в nginx, который обеспечивает совместимость с Apache mod_rewrite.
+
+## Файлы
+
+| Файл | Назначение |
+|------|------------|
+| `index.html` | Главная страница - назначение для перенаправления .xmx файлов |
+| `stop.html` | Заблокированная страница (должен возвращать 403) |
+| `redirect.html` | Внутреннее перенаправление на show.html (URL не меняется) |
+| `show.html` | Показывается вместо redirect.html при внутреннем rewrite |
+| `test.xmx` | Тестовый файл для проверки правила перенаправления .xmx расширения |
+
+## Правила .htaccess
+
+### 1. Перенаделение файлов с расширением `.xmx` на index.html
+
+```apache
+RewriteRule \.xmx$ /index.html [R=301,L]
+```
+
+**Ожидаемое поведение:**
+- Запрос `http://localhost/test/test.xmx` → **301 Redirect** к `/test/index.html`
+- URL в браузере изменится на `/test/index.html`
+
+### 2. Блокировка доступа к stop.html (403 Forbidden)
+
+```apache
+RewriteCond %{REQUEST_FILENAME} =stop.html
+RewriteRule ^ - [F,L]
+```
+
+**Ожидаемое поведение:**
+- Запрос `http://localhost/test/stop.html` → **403 Forbidden** ("Доступ запрещен")
+- Страница не будет отображаться
+
+### 3. Внутреннее перенаправление redirect.html на show.html
+
+```apache
+RewriteRule ^redirect\.html$ show.html [L]
+```
+
+**Ожидаемое поведение:**
+- Запрос `http://localhost/test/redirect.html` → **показывается содержимое show.html**
+- URL в браузере остается `/test/redirect.html` (не происходит перенаправления)
+
+### 4. Перенаделение подкаталога subdir на index.html
+
+```apache
+RewriteRule ^subdir/?$ /index.html [L]
+```
+
+**Ожидаемое поведение:**
+- Запрос `http://localhost/test/subdir/` → **показывается index.html**
+- URL в браузере остается `/test/subdir/`
+
+### 5. Дополнительные проверки
+
+- Флаг `[L]` (Last) - останавливает обработку правил после выполнения
+- Флаг `[F]` (Forbidden) - возвращает ошибку 403 Forbidden
+- Флаг `[R=301]` - внешнее перенаправление с кодом статуса 301 Moved Permanently
+
+## Порядок применения правил
+
+В модуле nginx приоритет следующий:
+
+1. **Правила из .htaccess** (высокий приоритет)
+2. **Правила из nginx конфигурации** (низкий приоритет)
+
+При наличии флага `[END]` в правилах .htaccess, дальнейшая обработка всех правил останавливается.
+
+## Поддержка флагоv mod_rewrite
+
+| Флаг | Значение | Описание |
+|------|----------|----------|
+| `L` | Last | Остановить обработку остальных правил |
+| `F` | Forbidden | Заблокировать доступ (403) |
+| `R=301` | Redirect | Внешнее перенаправление с кодом 301 |
+| `END` | End | Полностью остановить обработку rewrite |
+
+## Примеры запросов для тестирования
+
+```bash
+# Перенаделение .xmx файла на index.html
+curl -I http://localhost/test/test.xmx
+# Ожидаемый ответ: HTTP/1.1 301 Moved Permanently
+# Location: /test/index.html
+
+# Блокировка stop.html
+curl -I http://localhost/test/stop.html
+# Ожидаемый ответ: HTTP/1.1 403 Forbidden
+
+# Внутреннее перенаправление redirect.html на show.html
+curl -I http://localhost/test/redirect.html
+# Ожидаемый ответ: HTTP/1.1 200 OK (content из show.html)
+
+# Перенаделение subdir на index.html
+curl -I http://localhost/test/subdir/
+# Ожидаемый ответ: HTTP/1.1 200 OK (content из index.html)
+```
+
+## Установка и запуск
+
+Для запуска тестов потребуется:
+
+1. Скомпилированный nginx с модулем `ngx_http_apache_rewrite_module`
+2. Конфигурация nginx, указывающая каталог `test/` как корень сайта
+3. Активированный флаг `.htaccess` через директиву `HtAccess on`
+
+Пример конфигурации:
+
+```nginx
+server {
+    listen 80;
+    server_name localhost;
+    
+    location /test {
+        root /workspaces/test1/test;
+        
+        HtAccess on;
+        HtAccessFile .htaccess;
+    }
+}
+```
diff --git a/cms/simple/SUMMARY.md b/cms/simple/SUMMARY.md
new file mode 100644
index 0000000..a8e4fe7
--- /dev/null
+++ b/cms/simple/SUMMARY.md
@@ -0,0 +1,311 @@
+# Тесты Apache mod_rewrite для nginx - ПОЛНАЯ СУММАРИЯ
+
+## 📁 Структура тестовых файлов
+
+```
+/test1/test/
+├── .htaccess              # Главное правило rewrite для корневого каталога
+├── index.html             # Главная страница (назначение для redirect)
+├── show.html              # Показывается вместо redirect.html
+├── stop.html              # Блокируется (403 Forbidden)
+├── redirect.html          # Внутреннее перенаправление на show.html
+├── test.xmx               # Файл .xmx для тестирования расширения
+├── README.md              # Документация по тестам
+├── SUMMARY.md             # Эта страница - полная суммари
+└── subdir/                # Подкаталог с дополнительными тестами
+    ├── .htaccess          # Правила rewrite для подкаталога
+    ├── file.html          # Файл в подкаталоге
+    └── other.xmx          # Другой файл .xmx (блокируется)
+```
+
+---
+
+## 🔥 Ключевые правила .htaccess
+
+### 1️⃣ Перенаделение файлов с расширением `.xmx` на index.html
+
+**Правило:**
+```apache
+RewriteRule \.xmx$ /index.html [R=301,L]
+```
+
+**Ожидаемое поведение:**
+| Запрос | Результат |
+|--------|-----------|
+| `http://localhost/test/test.xmx` | 301 Redirect → `/test/index.html` |
+| URL в браузере меняется на `/test/index.html` | ✅ Внешнее перенаправление |
+
+**Логика:** 
+- Все файлы заканчивающиеся на `.xmx` перенаправляются на главную страницу
+- Используется флаг `[R=301]` для внешнего HTTP redirect
+- Флаг `[L]` останавливает дальнейшую обработку правил
+
+---
+
+### 2️⃣ Блокировка доступа к stop.html (403 Forbidden)
+
+**Правила:**
+```apache
+RewriteCond %{REQUEST_FILENAME} =stop.html
+RewriteRule ^ - [F,L]
+```
+
+**Ожидаемое поведение:**
+| Запрос | Результат |
+|--------|-----------|
+| `http://localhost/test/stop.html` | 403 Forbidden (Доступ запрещен) |
+| Страница не отображается | ✅ Полная блокировка |
+
+**Логика:**
+- `RewriteCond` проверяет что запрос именно к stop.html
+- `RewriteRule ^ - [F]` возвращает ошибку 403 Forbidden
+- Флаг `[L]` останавливает обработку
+
+---
+
+### 3️⃣ Внутреннее перенаправление redirect.html на show.html
+
+**Правило:**
+```apache
+RewriteRule ^redirect\.html$ show.html [L]
+```
+
+**Ожидаемое поведение:**
+| Запрос | Результат |
+|--------|-----------|
+| `http://localhost/test/redirect.html` | Показывается content из show.html |
+| URL в браузере остается `/test/redirect.html` | ✅ Internal rewrite |
+
+**Логика:**
+- Правило скрывает redirect.html и показывает вместо него show.html
+- Происходит внутренняя переадресация без изменения URL
+- Флаг `[L]` останавливает обработку
+
+---
+
+### 4️⃣ Перенаделение подкаталога subdir на index.html
+
+**Правило:**
+```apache
+RewriteRule ^subdir/?$ /index.html [L]
+```
+
+**Ожидаемое поведение:**
+| Запрос | Результат |
+|--------|-----------|
+| `http://localhost/test/subdir/` | Показывается content из index.html |
+| URL в браузере остается `/test/subdir/` | ✅ Internal rewrite |
+
+---
+
+### 5️⃣ Дополнительные проверки (из main .htaccess)
+
+**Правило:**
+```apache
+RewriteCond %{REQUEST_FILENAME} !test\.xmx$
+RewriteRule \.xmx$ - [F,L]
+```
+
+**Ожидаемое поведение:**
+- Блокирует все `.xmx` файлы кроме test.xmx
+- **НО:** Работает ПОСЛЕ правила 1, поэтому test.xmx сначала редиректится на index.html
+
+---
+
+### 6️⃣ Перенаделение subdir с последующей блокировкой (конфликт)
+
+**Порядок в .htaccess:**
+```apache
+# Сначала перенаправление
+RewriteRule ^subdir/?$ /index.html [L]
+
+# Затем блокировка
+RewriteRule ^subdir/?$ - [F,L]
+```
+
+**Ожидаемое поведение:**
+- subdir сначала переадресуется на index.html (правило 4)
+- Затем применяется правило блокировки → 403 Forbidden
+- **Итог:** subdir заблокирован с ошибкой 403
+
+---
+
+## 📁 Правила в подкаталоге `subdir/.htaccess`
+
+### 1️⃣ Блокировка всех .xmx файлов в subdir (кроме test.xmx)
+
+**Правило:**
+```apache
+RewriteRule \.xmx$ - [F,L]
+```
+
+**Ожидаемое поведение:**
+| Запрос | Результат |
+|--------|-----------|
+| `http://localhost/test/subdir/other.xmx` | 403 Forbidden |
+| Файл заблокирован | ✅ |
+
+---
+
+### 2️⃣ Внутреннее перенаправление subdir/file.html на ../show.html
+
+**Правило:**
+```apache
+RewriteRule ^file\.html$ ../show.html [L]
+```
+
+**Ожидаемое поведение:**
+| Запрос | Результат |
+|--------|-----------|
+| `http://localhost/test/subdir/file.html` | Показывается content из show.html (в родительском каталоге) |
+| URL остается `/test/subdir/file.html` | ✅ Internal rewrite с относительным путем |
+
+---
+
+### 3️⃣ Блокировка всех файлов кроме .html в subdir
+
+**Правило:**
+```apache
+RewriteCond %{REQUEST_FILENAME} !-ext=html
+RewriteRule ^ - [F,L]
+```
+
+**Ожидаемое поведение:**
+| Запрос | Результат |
+|--------|-----------|
+| `http://localhost/test/subdir/file.txt` | 403 Forbidden |
+| Только .html файлы доступны | ✅ Фильтрация по расширению |
+
+---
+
+## 🎯 Тестирование функционала mod_rewrite
+
+### Поддерживаемые флаги:
+
+| Флаг | Значение | Описание |
+|------|----------|----------|
+| `L` | Last | Остановить обработку остальных правил в .htaccess |
+| `F` | Forbidden | Возвращать ошибку 403 Forbidden |
+| `R=301` | Redirect | Внешнее перенаправление с кодом HTTP 301 Moved Permanently |
+| `END` | End | Остановить ВСЮ обработку rewrite (включая nginx config rules) |
+
+### Поддерживаемые директивы:
+
+| Директива | Описание |
+|-----------|----------|
+| `RewriteEngine on/off` | Включение/выключение mod_rewrite для .htaccess |
+| `RewriteRule pattern substitution [flags]` | Правило перенаправления |
+| `RewriteCond test string` | Условие для правила RewriteRule |
+
+---
+
+## 📊 Механизм приоритета
+
+### Порядок применения правил:
+
+```
+┌───────────────────────────────┐
+│ 1. Правила из .htaccess       │ ← Higher Priority
+│    ├─ Read & parse            │
+│    ├─ Convert to mod_rewrite  │
+│    └─ Apply rules             │
+│                                │
+├───────────────────────────────┤
+│ Check END flag                │
+│ if (ctx->end) STOP ALL        │ ← Blocks nginx config!
+├───────────────────────────────┤
+│ 2. Правила из nginx config    │ ← Lower Priority
+│    └─ Apply from server/loc   │
+└───────────────────────────────┘
+```
+
+**Ключевой момент:**
+- При наличии флага `[END]` в .htaccess, обработка ВСЕХ правил rewrite останавливается
+- Это позволяет полностью блокировать nginx config rules при необходимости
+
+---
+
+## 🧪 Примеры CURL запросов для тестирования
+
+```bash
+# 1. Перенаправление .xmx на index.html (301)
+curl -I http://localhost/test/test.xmx
+# Ожидаемый: HTTP/1.1 301 Moved Permanently
+#            Location: /test/index.html
+
+# 2. Блокировка stop.html (403)
+curl -I http://localhost/test/stop.html
+# Ожидаемый: HTTP/1.1 403 Forbidden
+
+# 3. Internal rewrite redirect.html → show.html (200 OK, content из show.html)
+curl -s http://localhost/test/redirect.html | grep h1
+# Ожидаемый: <h1>show.html</h1>
+
+# 4. Internal rewrite subdir → index.html (200 OK)
+curl -I http://localhost/test/subdir/
+# Ожидаемый: HTTP/1.1 200 OK
+
+# 5. Блокировка other.xmx в subdir (403)
+curl -I http://localhost/test/subdir/other.xmx
+# Ожидаемый: HTTP/1.1 403 Forbidden
+
+# 6. Internal rewrite subdir/file.html → ../show.html (200 OK)
+curl -s http://localhost/test/subdir/file.html | grep h1
+# Ожидаемый: <h1>show.html</h1>
+```
+
+---
+
+## 📝 Установка и запуск тестов
+
+### Конфигурация nginx для запуска тестов:
+
+```nginx
+server {
+    listen 80;
+    server_name localhost;
+    
+    # Корневой сайт
+    location / {
+        root /workspaces/test1/nginx-1.25.3/html;
+    }
+    
+    # Тестовый каталог с .htaccess поддержкой
+    location /test {
+        alias /workspaces/test1/test/;
+        
+        HtAccess on;          # Включить чтение .htaccess файлов
+        HtAccessFile .htaccess;  # Файл конфигурации
+        
+        # Для подкаталога subdir (авто-поиск .htaccess)
+    }
+}
+```
+
+### Команды запуска:
+
+```bash
+# 1. Скомпилировать nginx с модулем mod_rewrite
+cd /workspaces/test1/nginx-1.25.3 && make modules
+
+# 2. Запустить nginx
+./nginx -c /path/to/nginx.conf
+
+# 3. Тестировать правила через curl или браузер
+curl http://localhost/test/redirect.html
+```
+
+---
+
+## ✅ Итог
+
+Модуль `ngx_http_apache_rewrite_module` обеспечивает:
+
+1. ✅ **Чтение .htaccess файлов** при каждом запросе с проверкой mtime
+2. ✅ **Кэширование директив** в памяти на время жизненного цикла запроса  
+3. ✅ **Конвертацию Apache mod_rewrite правил** в формат nginx mod_rewrite
+4. ✅ **Приоритет .htaccess выше nginx config rules**
+5. ✅ **Флаг [END] для полной остановки обработки rewrite**
+6. ✅ **Поддержка флагоv L, F, R=301, END**
+
+Все тестовые файлы готовы и содержат документацию по ожидаемому поведению! 🎉
\ No newline at end of file
diff --git a/cms/simple/index.html b/cms/simple/index.html
new file mode 100644
index 0000000..43bc18a
--- /dev/null
+++ b/cms/simple/index.html
@@ -0,0 +1,40 @@
+<!doctype html>
+<html lang="ru">
+    <head>
+        <meta charset="UTF-8" />
+        <title>Index - Тест mod_rewrite для nginx</title>
+    </head>
+    <body>
+        <h1>index.html</h1>
+        <p>Вы попали на index.html.</p>
+        <p>
+            <strong
+                >Это страница назначения при перенаправлении файлов с
+                расширением xmx.</strong
+            >
+        </p>
+
+        <hr />
+        <ul>
+            <li><a href="show.html">Показать (show.html)</a></li>
+            <li><a href="stop.html">Stop - заблокированная страница</a></li>
+            <li>
+                <a href="redirect.html">Redirect - редирект на show.html</a>
+            </li>
+            <li><a href="subdir/">Подкаталог</a></li>
+        </ul>
+
+        <hr />
+        <p><em>Тесты mod_rewrite для nginx:</em></p>
+        <ol>
+            <li>
+                Запросите <code>.xmx</code> файл → перенаправление на index.html
+            </li>
+            <li>
+                Запросите <code>stop.html</code> → 403 Forbidden (доступ
+                запрещен)
+            </li>
+            <li>Запросите <code>redirect.html</code> → покажет show.html</li>
+        </ol>
+    </body>
+</html>
diff --git a/cms/simple/nginx.conf b/cms/simple/nginx.conf
new file mode 100644
index 0000000..9138219
--- /dev/null
+++ b/cms/simple/nginx.conf
@@ -0,0 +1,159 @@
+
+load_module modules/ngx_http_apache_rewrite_module.so;
+worker_processes  1;
+
+error_log  logs/error.log  debug;
+
+events {
+    worker_connections  1024;
+}
+
+
+http {
+    include       mime.types;
+    default_type  application/octet-stream;
+
+    sendfile        on;
+
+    keepalive_timeout  65;
+
+
+    server {
+        listen       8081;
+        server_name  localhost;
+
+
+        location / {
+            root   html;
+            index  index.html index.htm;
+        }
+
+        error_page   500 502 503 504  /50x.html;
+        location = /50x.html {
+            root   html;
+        }
+
+    }
+
+    server {
+        listen 8081;
+        server_name example1.com;
+
+        root /sites/site1;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+
+        location / {
+            RewriteEngine On;
+        }
+
+    }
+
+    server {
+        listen 8081;
+        server_name example2.com;
+
+        root /sites/site2;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock;
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example3.com;
+
+        root /sites/site3;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example4.com;
+
+        root /sites/site4;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example5.com;
+
+        root /sites/site5;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+}
diff --git a/cms/simple/redirect.html b/cms/simple/redirect.html
new file mode 100644
index 0000000..936ace4
--- /dev/null
+++ b/cms/simple/redirect.html
@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="ru">
+    <head>
+        <meta charset="UTF-8" />
+        <title>Redirect - Тест mod_rewrite для nginx</title>
+    </head>
+    <body>
+        <h1>redirect.html</h1>
+        <p>Вы попали на redirect.html.</p>
+
+        <hr />
+        <ul>
+            <li><a href="index.html">На главную (index.html)</a></li>
+            <li><a href="show.html">Показать (show.html)</a></li>
+            <li><a href="stop.html">Stop - заблокированная</a></li>
+        </ul>
+
+        <hr />
+        <p>
+            <em><strong style="color: green;">Эта страница должна быть скрыта!</strong></em>
+        </p>
+        <p>
+            При обращении к redirect.html, mod_rewrite должен показать show.html вместо этой страницы.
+        </p>
+    </body>
+</html>
diff --git a/cms/simple/show.html b/cms/simple/show.html
new file mode 100644
index 0000000..6d95443
--- /dev/null
+++ b/cms/simple/show.html
@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="ru">
+    <head>
+        <meta charset="UTF-8" />
+        <title>Show - Тест mod_rewrite для nginx</title>
+    </head>
+    <body>
+        <h1>show.html</h1>
+        <p>Вы попали на show.html.</p>
+
+        <hr />
+        <ul>
+            <li><a href="index.html">На главную (index.html)</a></li>
+            <li><a href="redirect.html">Redirect - перенаправляет сюда</a></li>
+            <li><a href="stop.html">Stop - заблокированная</a></li>
+        </ul>
+
+        <hr />
+        <p>
+            <em><strong style="color: green;">Показано вместо redirect.html!</strong></em>
+        </p>
+        <p>
+            Это страница-назначение для правила <code>RewriteRule ^redirect\.html$ show.html [L]</code>.
+        </p>
+    </body>
+</html>
diff --git a/cms/simple/site1.conf b/cms/simple/site1.conf
new file mode 100644
index 0000000..c09f368
--- /dev/null
+++ b/cms/simple/site1.conf
@@ -0,0 +1,10 @@
+<VirtualHost 192.168.3.96:80>
+    DocumentRoot "/sites/site1"
+    ServerName example1.com
+
+    <Directory /sites/site1>
+        Options +Indexes +FollowSymLinks
+        AllowOverride All
+        Require all granted
+    </Directory>
+</VirtualHost>
diff --git a/cms/simple/somedir/.gitkeep b/cms/simple/somedir/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/cms/simple/stop.html b/cms/simple/stop.html
new file mode 100644
index 0000000..9a29685
--- /dev/null
+++ b/cms/simple/stop.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<html lang="ru">
+    <head>
+        <meta charset="UTF-8" />
+        <title>Stop - Тест mod_rewrite для nginx</title>
+    </head>
+    <body>
+        <h1>stop.html</h1>
+        <p>Вы попали на stop.html.</p>
+
+        <hr />
+        <ul>
+            <li><a href="index.html">На главную (index.html)</a></li>
+            <li><a href="show.html">Показать (show.html)</a></li>
+            <li><a href="redirect.html">Redirect</a></li>
+        </ul>
+
+        <hr />
+        <p>
+            <em><strong style="color: red;">Эта страница должна быть заблокирована!</strong></em>
+        </p>
+    </body>
+</html>
diff --git a/cms/simple/subdir/.gitkeep b/cms/simple/subdir/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/cms/simple/subdir/.htaccess b/cms/simple/subdir/.htaccess
new file mode 100644
index 0000000..fb1bbfa
--- /dev/null
+++ b/cms/simple/subdir/.htaccess
@@ -0,0 +1,30 @@
+# ============================================================
+#   .htaccess в подкаталоге subdir - Тесты mod_rewrite для nginx
+# ============================================================
+# Этот файл проверяет работу правил для конкретного location (подкаталога)
+
+RewriteEngine On
+
+# Правило 1: Все запросы к файлам с расширением xmx в этом подкаталоге
+# должны блокироваться с ошибкой 403 Forbidden
+
+RewriteRule \.xmx$ - [F,L]
+
+# Тестирование:
+# - http://localhost/test/subdir/other.xmx → 403 Forbidden
+
+# Правило 2: Внутреннее перенаделение subdir/file.html на ../show.html
+# (переход из подкаталога в родительский)
+
+RewriteRule ^file\.html$ ../show.html [L]
+
+# Тестирование:
+# - http://localhost/test/subdir/file.html → показывает содержимое show.html
+
+# Правило 3: Блокировка доступа ко всем файлам кроме .html
+
+RewriteCond %{REQUEST_URI} !\.html$
+RewriteRule ^ - [F,L]
+
+# Тестирование:
+# - http://localhost/test/subdir/file.txt → 403 Forbidden
diff --git a/cms/simple/subdir/file.html b/cms/simple/subdir/file.html
new file mode 100644
index 0000000..789b1cd
--- /dev/null
+++ b/cms/simple/subdir/file.html
@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="ru">
+    <head>
+        <meta charset="UTF-8" />
+        <title>File - Тест mod_rewrite для nginx</title>
+    </head>
+    <body>
+        <h1>file.html</h1>
+        <p>Вы попали на file.html в подкаталоге subdir.</p>
+
+        <hr />
+        <ul>
+            <li><a href="../index.html">На главную (index.html)</a></li>
+            <li><a href="../show.html">Показать (show.html)</a></li>
+            <li><a href="../redirect.html">Redirect</a></li>
+        </ul>
+
+        <hr />
+        <p>
+            <em><strong style="color: green;">Это страница из подкаталога!</strong></em>
+        </p>
+        <p>
+            При обращении к <code>/test/subdir/file.html</code>, mod_rewrite должен показать содержимое <code>../show.html</code>.
+        </p>
+    </body>
+</html>
diff --git a/cms/simple/subdir/other.xmx b/cms/simple/subdir/other.xmx
new file mode 100644
index 0000000..06b90cf
--- /dev/null
+++ b/cms/simple/subdir/other.xmx
@@ -0,0 +1,27 @@
+<!doctype html>
+<html lang="ru">
+    <head>
+        <meta charset="UTF-8" />
+        <title>Other XMX - Тест mod_rewrite для nginx</title>
+    </head>
+    <body>
+        <h1>other.xmx</h1>
+        <p>Вы попытались получить этот файл.</p>
+
+        <hr />
+        <ul>
+            <li><a href="../index.html">На главную (index.html)</a></li>
+            <li><a href="../show.html">Показать (show.html)</a></li>
+            <li><a href="file.html">File.html</a></li>
+        </ul>
+
+        <hr />
+        <p>
+            <em><strong style="color: red;">Этот файл должен быть заблокирован!</strong></em>
+        </p>
+        <p>
+            При обращении к <code>/test/subdir/other.xmx</code>, mod_rewrite должен вернуть
+            <code style="background-color: #f00; color: white;">403 Forbidden</code>.
+        </p>
+    </body>
+</html>
diff --git a/cms/simple/test.xmx b/cms/simple/test.xmx
new file mode 100644
index 0000000..49e31a7
--- /dev/null
+++ b/cms/simple/test.xmx
@@ -0,0 +1,26 @@
+# Test File - test.xmx
+
+This is a test file used to verify the mod_rewrite rule that redirects all files ending with .xmx extension to index.html.
+
+## How it works:
+
+When you request any `.xmx` file in this directory, the following rule from `.htaccess` will be applied:
+
+```
+RewriteRule \.xmx$ /index.html [R=301,L]
+```
+
+This redirects your browser to `/index.html`.
+
+## Test URLs:
+
+- `http://localhost/test/test.xmx` → redirects to `/test/index.html`
+- `http://localhost/test/subdir/other.xmx` → redirects to `/test/index.html`
+- `http://localhost/test/deep/path/file.xmx` → redirects to `/test/index.html`
+
+## Additional Test Files:
+
+See other test pages in this directory:
+- index.html - main page
+- show.html - shown instead of redirect.html via internal rewrite
+- stop.html - should be blocked (403 Forbidden) by mod_rewrite rules
diff --git a/cms/wordpress-multy/.htaccess b/cms/wordpress-multy/.htaccess
new file mode 100644
index 0000000..8e760c7
--- /dev/null
+++ b/cms/wordpress-multy/.htaccess
@@ -0,0 +1,14 @@
+RewriteEngine On
+RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+RewriteBase /
+RewriteRule ^index\.php$ - [L]
+
+# add a trailing slash to /wp-admin
+RewriteRule ^([_0-9a-zA-Z-]+/)?wp-admin$ $1wp-admin/ [R=301,L]
+
+RewriteCond %{REQUEST_FILENAME} -f [OR]
+RewriteCond %{REQUEST_FILENAME} -d
+RewriteRule ^ - [L]
+RewriteRule ^([_0-9a-zA-Z-]+/)?(wp-(content|admin|includes).*) $2 [L]
+RewriteRule ^([_0-9a-zA-Z-]+/)?(.*\.php)$ $2 [L]
+RewriteRule . index.php [L]
diff --git a/cms/wordpress-multy/README.md b/cms/wordpress-multy/README.md
new file mode 100644
index 0000000..9846401
--- /dev/null
+++ b/cms/wordpress-multy/README.md
@@ -0,0 +1,152 @@
+# WordPress Multisite Test Structure - Documentation
+
+## Directory Layout Overview
+
+```
+/test1/cms/wordpress-multy/
+├── index.php                  - WordPress entry point (routes non-existing files)
+│                                - Returns: "WordPress Multisite Content Route" page
+├── wp-admin/                  - Admin directory tests
+│   └── (empty directory for trailing slash redirect test)
+├── wp-admin/admin.php         - Test file for wp-admin routing rule
+├── wp-content/                - WordPress content directory tests
+│   └── themes/                - Theme subdirectory
+├── wp-includes/               - Core files directory tests  
+│   └── js/                    - JavaScript subdirectory
+│   └── (empty for testing)
+├── style.css                  - Existing CSS file (tests RewriteRule !-f condition)
+├── script.js                  - Existing JS file (tests RewriteRule !-f condition)
+├── test-wp-multi-rewriterules.sh - Bash script to test all rules using curl
+└── README.md                  - This documentation file
+```
+
+## Apache Rules Explained - WordPress Multisite
+
+### 1. HTTP Authorization Header Passing
+
+```apache
+RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+```
+
+**Что делает:** Копирует HTTP Authorization header в переменную HTTP_AUTHORIZATION для PHP
+
+### 2. RewriteBase Configuration
+
+```apache
+RewriteBase /
+```
+
+**Что делает:** Устанавливает базовый путь к корню сайта
+
+### 3. Direct index.php Access Protection
+
+```apache
+RewriteRule ^index\.php$ - [L]
+```
+
+**Что делает:** Предотвращает зацикливание маршрутизации (не переписывает прямой запрос на index.php)
+
+### 4. wp-admin Trailing Slash Redirect
+
+```apache
+# add a trailing slash to /wp-admin
+RewriteRule ^([_0-9a-zA-Z-]+/)?wp-admin$ $1wp-admin/ [R=301,L]
+```
+
+**Что делает:** Добавляет слэш в конце к URL `/wp-admin`, редирект 301 (Moved Permanently)
+
+**Зачем нужно:** WordPress multisite требует trailing slash для admin panel, обеспечивает корректную маршрутизацию
+
+**Подхват поддомена:** `[_0-9a-zA-Z-]+/?` позволяет обработку поддоменов в multisite setup:
+- `/wp-admin` → редирект на `/wp-admin/` (301)
+- `site.subdomain.com/wp-admin` → редирект на `site.subdomain.com/wp-admin/`
+
+### 5. Existing Files/Directories Check (Skip Processing)
+
+```apache
+RewriteCond %{REQUEST_FILENAME} -f [OR]
+RewriteCond %{REQUEST_FILENAME} -d
+RewriteRule ^ - [L]
+```
+
+**Что делает:** Если файл ИЛИ директория СУЩЕСТВУЕТ - останавливаем обработку правил, пропускаем запрос напрямую
+
+**Зачем нужно:** Предотвращает маршрутизацию на index.php для существующих статических файлов (CSS, JS, изображения)
+
+### 6. WordPress Multisite Core Routing Rules
+
+```apache
+RewriteRule ^([_0-9a-zA-Z-]+/)?(wp-(content|admin|includes).*) $2 [L]
+```
+
+**Что делает:** Для multisite setups - маршрутизирует wp-content, wp-admin, wp-includes напрямую (без index.php)
+
+**Подхват поддоменов:** `[_0-9a-zA-Z-]+/?` позволяет обработку поддоменов в multisite:
+- `/wp-content/uploads/image.jpg` → прямой доступ к файлу
+- `site.subdomain.com/wp-admin/admin.php` → прямая маршрутизация к admin.php
+
+### 7. All PHP Files Direct Access
+
+```apache
+RewriteRule ^([_0-9a-zA-Z-]+/)?(.*\.php)$ $2 [L]
+```
+
+**Что делает:** Любой PHP файл отдаётся напрямую, без маршрутизации через index.php
+
+**Подхват поддоменов:** `[_0-9a-zA-Z-]+/?` позволяет обработку поддоменов в multisite:
+- `/wp-login.php` → прямой доступ к файлу
+- `site.subdomain.com/wp-signup.php` → прямая маршрутизация к signup.php
+
+### 8. Final WordPress Routing Rule
+
+```apache
+RewriteRule . index.php [L]
+```
+
+**Что делает:** Все оставшиеся запросы маршрутизируются через index.php (основной URL routing)
+
+## Test Script Features
+
+The script includes test functions:
+1. **test_rule()** - checks HTTP status code only
+2. **test_rule_content()** - checks both status AND response body content
+
+## Multisite-Specific Testing Scenarios
+
+### Subdomain vs Subdirectory Setup
+
+WordPress Multisite может быть configured в двух режимах:
+- **Subdomain mode**: sites поддоменами (site1.example.com, site2.example.com)
+- **Subdirectory mode**: сайты поддиректориями (/site1/, /site2/)
+
+Правило `[_0-9a-zA-Z-]+/?` обрабатывает оба случая:
+- Для subdomain: `[subdomain/]?` = optional prefix
+- Для subdirectory: `[directory/]?` = optional prefix
+
+### Test Examples
+
+| URL | Правило | Ожидаемый результат |
+|-----|---------|---------------------|
+| `http://test.my.brp/wp-admin` | trailing slash redirect | 301 → `/wp-admin/` ✓ |
+| `http://test.my.brp/wp-admin/` | direct access (directory exists) | 200 OK ✓ |
+| `http://test.my.brp/style.css` | existing file (!-f passes) | 200 OK ✓ |
+| `http://test.my.brp/script.js` | existing file (!-f passes) | 200 OK ✓ |
+| `http://test.my.brp/wp-admin/admin.php` | multisite wp-admin rule | 200 OK ✓ |
+| `http://test.my.brp/wp-content/uploads/test.jpg` | multisite wp-content rule | 200 OK ✓ |
+| `http://test.my.brp/nonexistent-page/` | final index.php routing | 200 OK (content from index.php) ✓ |
+
+## Run Tests
+
+Execute the test script to verify all rules:
+```bash
+cd /home/alexey/projects/workspace-zed/test1/cms/wordpress-multy
+./test-wp-multi-rewriterules.sh
+```
+
+Expected results for WordPress Multisite tests (all should be **PASS ✓**):
+- wp-admin trailing slash redirect: HTTP 301 ✓
+- wp-admin directory access: HTTP 200 ✓
+- Existing file (CSS/JS) access: HTTP 200 ✓
+- Existing directory access: HTTP 200 ✓
+- WordPress multisite routing (wp-content, admin): HTTP 200 ✓
+- Final index.php routing: HTTP 200 + content "WordPress Multisite Content Route" ✓
diff --git a/cms/wordpress-multy/custom-script.php b/cms/wordpress-multy/custom-script.php
new file mode 100644
index 0000000..0878f5b
--- /dev/null
+++ b/cms/wordpress-multy/custom-script.php
@@ -0,0 +1,6 @@
+<?php
+// WordPress Multisite Test PHP File
+// This file is tested via RewriteRule ^([_0-9a-zA-Z-]+/)?(.*\.php)$ $2 [L]
+// Any .php file access rule
+
+echo "WordPress Multisite custom script - direct PHP file access";
diff --git a/cms/wordpress-multy/index.php b/cms/wordpress-multy/index.php
new file mode 100644
index 0000000..0fd728d
--- /dev/null
+++ b/cms/wordpress-multy/index.php
@@ -0,0 +1,15 @@
+<?php
+/**
+ * WordPress Multisite - index.php (Test version)
+ * This file handles routing for non-existing files/directories in multisite setup
+ */
+
+// Simulated WordPress Multisite response
+echo "<html><head><title>WordPress Multisite Test Site</title></head><body>";
+echo "<h1>WordPress Multisite Content Route</h1>";
+echo "<p>This page is served by index.php via RewriteRule.</p>";
+echo "<div class='wp-multisite-config'>WordPress Multisite Configuration Loaded</div>";
+echo "</body></html>";
+
+// Exit
+exit;
diff --git a/cms/wordpress-multy/script.js b/cms/wordpress-multy/script.js
new file mode 100644
index 0000000..6308d09
--- /dev/null
+++ b/cms/wordpress-multy/script.js
@@ -0,0 +1,4 @@
+// WordPress Multisite Test JS File
+// This file is tested via RewriteCond !-f (existing files skip routing)
+
+console.log('WordPress Multisite CSS/JS test file');
diff --git a/cms/wordpress-multy/style.css b/cms/wordpress-multy/style.css
new file mode 100644
index 0000000..fea74b3
--- /dev/null
+++ b/cms/wordpress-multy/style.css
@@ -0,0 +1,8 @@
+/* WordPress Multisite Test CSS File */
+/* This file is tested via RewriteCond !-f (existing files skip routing) */
+
+body {
+    font-family: 'Arial', sans-serif;
+    margin: 0;
+    padding: 20px;
+}
diff --git a/cms/wordpress-multy/test-wp-multi-rewriterules.sh b/cms/wordpress-multy/test-wp-multi-rewriterules.sh
new file mode 100755
index 0000000..833e9c0
--- /dev/null
+++ b/cms/wordpress-multy/test-wp-multi-rewriterules.sh
@@ -0,0 +1,171 @@
+#!/bin/bash
+
+# ============================================
+# WordPress Multisite .htaccess Rules Test Script
+# ============================================
+# This script tests each rule from cms/wordpress-multy/.htaccess
+# Assumption: Site root is mapped to /home/alexey/projects/workspace-zed/test1/cms/wordpress-multy
+# Domain: test.my.brp
+# ============================================
+
+BASE_URL="http://test.my.brp"
+
+echo "=============================================="
+echo "WordPress Multisite .htaccess Rules Test Suite"
+echo "=============================================="
+echo ""
+
+# Function to test a rule and report result (status only)
+test_rule() {
+    local description="$1"
+    local url="$2"
+    local expected_status="$3"  # e.g., 403, 404, 200, 301
+
+    echo "--- Test: $description ---"
+    response=$(curl -s -o /dev/null -w "%{http_code}" "$url")
+
+    if [ "$response" = "$expected_status" ]; then
+        echo "✓ PASS (HTTP $response)"
+    else
+        echo "✗ FAIL (Expected: HTTP $expected_status, Got: HTTP $response)"
+    fi
+    echo ""
+}
+
+# Function to test a rule and verify content contains expected string
+test_rule_content() {
+    local description="$1"
+    local url="$2"
+    local expected_status="$3"  # e.g., 403, 404, 200, 301
+    local expected_content="$4"  # Expected substring in response body
+
+    echo "--- Test: $description ---"
+    response=$(curl -s "$url")
+    http_code=$(curl -s -o /dev/null -w "%{http_code}" "$url")
+
+    # Check status code
+    if [ "$http_code" != "$expected_status" ]; then
+        echo "✗ FAIL (Status: HTTP $http_code, Expected: HTTP $expected_status)"
+        return 1
+    fi
+
+    # Check content contains expected substring
+    if [[ "$response" == *"$expected_content"* ]]; then
+        echo "✓ PASS (HTTP $http_code, Content matches '$expected_content')"
+    else
+        echo "✗ FAIL (Content missing: '$expected_content') - Response:"
+        echo "$response" | head -5
+    fi
+    echo ""
+}
+
+echo "=============================================="
+echo "1. HTTP Authorization Header Handling"
+echo "=============================================="
+# Test that Authorization header is properly handled by WordPress Multisite API
+test_rule_content "WordPress multisite handles Authorization header (API request)" \
+    "$BASE_URL/wp-json/wp/v2/posts?Authorization=Bearer secret_token_123" \
+    "200" \
+    "WordPress Multisite Configuration Loaded"
+
+echo ""
+echo "=============================================="
+echo "2. RewriteBase Root Configuration"
+echo "=============================================="
+# Test root directory access with proper base path routing
+test_rule_content "Root directory access (base path /)" \
+    "$BASE_URL/" \
+    "200" \
+    "WordPress Multisite Content Route"
+
+echo ""
+echo "=============================================="
+echo "3. Direct index.php Access Protection"
+echo "=============================================="
+# Test direct access to index.php - should NOT be rewritten (prevents infinite loop)
+test_rule_content "Direct index.php access (not rewritten)" \
+    "$BASE_URL/index.php" \
+    "200" \
+    "WordPress Multisite Configuration Loaded"
+
+echo ""
+echo "=============================================="
+echo "4. wp-admin Trailing Slash Redirect Rule"
+echo "=============================================="
+# Test trailing slash redirect for /wp-admin (301 Moved Permanently)
+test_rule_content "wp-admin trailing slash redirect (301)" \
+    "$BASE_URL/wp-admin" \
+    "301"
+
+# Test that /wp-admin/ with trailing slash works correctly (existing directory)
+test_rule_content "wp-admin/ with trailing slash (exists as directory)" \
+    "$BASE_URL/wp-admin/" \
+    "200" \
+    "WordPress Multisite Content Route"
+
+echo ""
+echo "=============================================="
+echo "5. Existing Files/Directories Check Rule"
+echo "=============================================="
+# Test existing CSS file access (!-f condition passes) - should return 200 OK without routing to index.php
+test_rule "Existing CSS file access (style.css)" \
+    "$BASE_URL/style.css" \
+    "200"
+
+# Test existing JS file access (!-f condition passes) - should return 200 OK without routing to index.php
+test_rule "Existing JS file access (script.js)" \
+    "$BASE_URL/script.js" \
+    "200"
+
+echo ""
+echo "=============================================="
+echo "6. WordPress Multisite Core Routing Rules"
+echo "=============================================="
+# Test wp-admin specific routing rule (not through index.php)
+test_rule_content "wp-admin/admin.php multisite routing" \
+    "$BASE_URL/wp-admin/admin.php" \
+    "200" \
+    "WordPress Multisite Content Route"
+
+# Test wp-content specific routing rule (for uploads, themes etc.)
+test_rule_content "wp-content/uploads/test.jpg multisite routing" \
+    "$BASE_URL/wp-content/uploads/test.jpg" \
+    "200" \
+    "WordPress Multisite Content Route"
+
+# Test wp-includes specific routing rule (core files)
+test_rule_content "wp-includes/js/jquery.js multisite routing" \
+    "$BASE_URL/wp-includes/js/jquery.js" \
+    "200" \
+    "WordPress Multisite Content Route"
+
+echo ""
+echo "=============================================="
+echo "7. All PHP Files Direct Access Rule"
+echo "=============================================="
+# Test any .php file access (not routed through index.php) - custom script returns specific content
+test_rule_content "Any PHP file access (.php rule)" \
+    "$BASE_URL/custom-script.php" \
+    "200" \
+    "WordPress Multisite custom script - direct PHP file access"
+
+echo ""
+echo "=============================================="
+echo "8. Final WordPress Routing Rule"
+echo "=============================================="
+# Test non-existing file routing through index.php (main routing)
+test_rule_content "Non-existing page routing (routes to index.php)" \
+    "$BASE_URL/nonexistent-page/" \
+    "200" \
+    "WordPress Multisite Content Route"
+
+# Test non-existing directory routing through index.php (routes to index.php)
+test_rule_content "Non-existing directory routing (routes to index.php)" \
+    "$BASE_URL/nonexistent-directory/" \
+    "200" \
+    "WordPress Multisite Content Route"
+
+echo ""
+echo "=============================================="
+echo "Test Suite Complete"
+echo "=============================================="
diff --git a/cms/wordpress-multy/wp-admin/admin.php b/cms/wordpress-multy/wp-admin/admin.php
new file mode 100644
index 0000000..9e3f2e0
--- /dev/null
+++ b/cms/wordpress-multy/wp-admin/admin.php
@@ -0,0 +1,2 @@
+# WordPress Multisite admin.php test file
+# This file is tested via RewriteRule ^([_0-9a-zA-Z-]+/)?(wp-(content|admin|includes).*) $2 [L]
diff --git a/cms/wordpress-multy/wp-content/themes/.gitkeep b/cms/wordpress-multy/wp-content/themes/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/cms/wordpress-multy/wp-content/uploads/test.jpg b/cms/wordpress-multy/wp-content/uploads/test.jpg
new file mode 100644
index 0000000..fa1f7f6
--- /dev/null
+++ b/cms/wordpress-multy/wp-content/uploads/test.jpg
@@ -0,0 +1,2 @@
+# WordPress Multisite test.jpg file for wp-content routing rule
+# This file is tested via RewriteRule ^([_0-9a-zA-Z-]+/)?(wp-(content|admin|includes).*) $2 [L]
diff --git a/cms/wordpress-multy/wp-includes/js/jquery.js b/cms/wordpress-multy/wp-includes/js/jquery.js
new file mode 100644
index 0000000..2fc02f1
--- /dev/null
+++ b/cms/wordpress-multy/wp-includes/js/jquery.js
@@ -0,0 +1,2 @@
+# WordPress Multisite jquery.js file for wp-includes routing rule
+# This file is tested via RewriteRule ^([_0-9a-zA-Z-]+/)?(wp-(content|admin|includes).*) $2 [L]
diff --git a/cms/wordpress/nginx.conf b/cms/wordpress/nginx.conf
new file mode 100644
index 0000000..9138219
--- /dev/null
+++ b/cms/wordpress/nginx.conf
@@ -0,0 +1,159 @@
+
+load_module modules/ngx_http_apache_rewrite_module.so;
+worker_processes  1;
+
+error_log  logs/error.log  debug;
+
+events {
+    worker_connections  1024;
+}
+
+
+http {
+    include       mime.types;
+    default_type  application/octet-stream;
+
+    sendfile        on;
+
+    keepalive_timeout  65;
+
+
+    server {
+        listen       8081;
+        server_name  localhost;
+
+
+        location / {
+            root   html;
+            index  index.html index.htm;
+        }
+
+        error_page   500 502 503 504  /50x.html;
+        location = /50x.html {
+            root   html;
+        }
+
+    }
+
+    server {
+        listen 8081;
+        server_name example1.com;
+
+        root /sites/site1;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+
+        location / {
+            RewriteEngine On;
+        }
+
+    }
+
+    server {
+        listen 8081;
+        server_name example2.com;
+
+        root /sites/site2;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock;
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example3.com;
+
+        root /sites/site3;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example4.com;
+
+        root /sites/site4;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+    server {
+        listen 8081;
+        server_name example5.com;
+
+        root /sites/site5;
+
+        HtaccessEnable on;
+
+        RewriteEngine On;
+        index index.php;
+
+        location / {
+    	    RewriteEngine On;
+    	    autoindex on;
+        }
+
+        location ~* \.php$ {
+            RewriteEngine On;
+    	    include fastcgi_params;
+    	    fastcgi_split_path_info ^(.+\.php)(/.+)$;
+    	    fastcgi_pass unix:/run/php-fpm/www.sock; # подключаем сокет php-fpm
+    	    fastcgi_index index.php;
+    	    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+	}
+    }
+
+}
diff --git a/cms/wordpress/site3.conf b/cms/wordpress/site3.conf
new file mode 100644
index 0000000..f6986cc
--- /dev/null
+++ b/cms/wordpress/site3.conf
@@ -0,0 +1,16 @@
+<VirtualHost *:80>
+    DocumentRoot "/sites/site3"
+    ServerName example3.com
+
+    DirectoryIndex index.php
+
+    <Directory /sites/site3/wordpress>
+        Options +Indexes +FollowSymLinks
+        AllowOverride All
+        Require all granted
+    </Directory>
+    <FilesMatch \.php$>
+	    SetHandler "proxy:unix:/run/php-fpm/www.sock|fcgi://localhost"
+    </FilesMatch>
+
+</VirtualHost>
diff --git a/cms/wordpress/test-wp-rewriterules.sh b/cms/wordpress/test-wp-rewriterules.sh
new file mode 100755
index 0000000..1d2d083
--- /dev/null
+++ b/cms/wordpress/test-wp-rewriterules.sh
@@ -0,0 +1,140 @@
+#!/bin/bash
+
+# ============================================
+# WordPress .htaccess Rules Test Script
+# ============================================
+# This script tests each rule from cms/wordpress/.htaccess
+# Assumption: Site root is mapped to /home/alexey/projects/workspace-zed/test1/cms/wordpress
+# Domain: test.my.brp
+# ============================================
+
+BASE_URL="http://test.my.brp"
+
+echo "=============================================="
+echo "WordPress .htaccess Rules Test Suite"
+echo "=============================================="
+echo ""
+
+# Function to test a rule and report result (status only)
+test_rule() {
+    local description="$1"
+    local url="$2"
+    local expected_status="$3"  # e.g., 403, 404, 200
+
+    echo "--- Test: $description ---"
+    response=$(curl -s -o /dev/null -w "%{http_code}" "$url")
+
+    if [ "$response" = "$expected_status" ]; then
+        echo "✓ PASS (HTTP $response)"
+    else
+        echo "✗ FAIL (Expected: HTTP $expected_status, Got: HTTP $response)"
+    fi
+    echo ""
+}
+
+# Function to test a rule and verify content contains expected string
+test_rule_content() {
+    local description="$1"
+    local url="$2"
+    local headers="$3"  # Optional: additional curl -H header flags (can be empty)
+    local expected_status="$4"  # e.g., 403, 404, 200
+    local expected_content="$5"  # Expected substring in response body
+
+    echo "--- Test: $description ---"
+
+    if [ -n "$headers" ]; then
+        response=$(curl -s -H "$headers" "$url")
+        http_code=$(curl -s -H "$headers" -o /dev/null -w "%{http_code}" "$url")
+    else
+        response=$(curl -s "$url")
+        http_code=$(curl -s -o /dev/null -w "%{http_code}" "$url")
+    fi
+
+    # Check status code
+    if [ "$http_code" != "$expected_status" ]; then
+        echo "✗ FAIL (Status: HTTP $http_code, Expected: HTTP $expected_status)"
+        return 1
+    fi
+
+    # Check content contains expected substring
+    if [[ "$response" == *"$expected_content"* ]]; then
+        echo "✓ PASS (HTTP $http_code, Content matches '$expected_content')"
+    else
+        echo "✗ FAIL (Content missing: '$expected_content') - Response:"
+        echo "$response" | head -5
+    fi
+    echo ""
+}
+
+echo "=============================================="
+echo "1. HTTP_AUTHORIZATION Header Rewrite Rule"
+echo "=============================================="
+# Test that Authorization header is properly handled by WordPress REST API mock
+# This rule copies HTTP Authorization header to HTTP_AUTHORIZATION env var via mod_rewrite [E=...]
+test_rule_content "WordPress REST API: Authorization header passed through mod_rewrite" \
+    "$BASE_URL/wordpress/wp-json/wp/v2/posts" \
+    "Authorization: secret_token_123" \
+    "200" \
+    "\"status\": \"success\""
+
+# Additional test: verify token verification in response
+test_rule_content "WordPress REST API: Token verified correctly" \
+    "$BASE_URL/wordpress/wp-json/wp/v2/posts" \
+    "" \
+    "401" \
+    "\"message\": \"unauth\""
+
+echo ""
+echo "=============================================="
+echo "2. RewriteBase Configuration"
+echo "=============================================="
+# RewriteBase / sets base path to root - verifies routing works correctly
+test_rule_content "Base path routing (root directory)" \
+    "$BASE_URL/wordpress/" \
+    "" \
+    "200" \
+    "WordPress Content Route"
+
+echo ""
+echo "=============================================="
+echo "3. Direct index.php Access Protection"
+echo "=============================================="
+# RewriteRule ^index\.php$ - [L] - direct access to index.php should return 200 OK
+test_rule_content "Direct index.php access (not rewritten)" \
+    "$BASE_URL/wordpress/index.php" \
+    "" \
+    "200" \
+    "WordPress Content Route"
+
+echo ""
+echo "=============================================="
+echo "4. WordPress Core Routing Rules"
+echo "=============================================="
+# Test non-existing file routes through index.php (!-f condition)
+test_rule_content "Non-existing file routing (routes to index.php)" \
+    "$BASE_URL/wordpress/nonexistent-page/" \
+    "" \
+    "200" \
+    "WordPress Content Route"
+
+# Test existing file access - should return 200 OK (!-f passes for existing files)
+test_rule "Existing file access (existing.jpg)" \
+    "$BASE_URL/wordpress/existing.jpg" \
+    "200"
+
+# Test non-existing directory routing - should route to index.php (!-d condition)
+test_rule_content "Non-existing directory routing (routes to index.php)" \
+    "$BASE_URL/wordpress/nonexistent-dir/" \
+    "" \
+    "200" \
+    "WordPress Content Route"
+
+# Test existing directory access - should return 200 OK (!-d passes for existing dirs)
+test_rule "Existing directory access (somedir/)" \
+    "$BASE_URL/wordpress/somedir/" \
+    "200"
+
+echo ""
+echo "=============================================="
+echo "Test Suite Complete"
+echo "=============================================="
diff --git a/cms/wordpress/wordpress/.htaccess b/cms/wordpress/wordpress/.htaccess
new file mode 100644
index 0000000..e4be13a
--- /dev/null
+++ b/cms/wordpress/wordpress/.htaccess
@@ -0,0 +1,8 @@
+RewriteEngine On
+RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+RewriteBase /wordpress
+RewriteRule ^wp-json/(.*)$ wp_api.php?api=$1 [L,QSA]
+RewriteRule ^index\.php$ - [L]
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteRule . index.php [L]
diff --git a/cms/wordpress/wordpress/README.md b/cms/wordpress/wordpress/README.md
new file mode 100644
index 0000000..429bfd3
--- /dev/null
+++ b/cms/wordpress/wordpress/README.md
@@ -0,0 +1,109 @@
+# WordPress .htaccess Test Structure
+
+## Directory Layout Overview
+
+```
+/test1/cms/wordpress/
+├── existing.jpg       - Existing file for routing test (200 OK)
+│                      - Tests: RewriteRule !-f condition passes for existing files
+├── index.php          - WordPress entry point
+│                      - Returns: "WordPress Content Route" page
+│                      - Used by Rule 3 (direct access protection) and Rule 4 (routing)
+├── README.md          - This documentation file
+├── somedir/           - Existing directory for routing test (200 OK)
+│                      - Tests: RewriteRule !-d condition passes for existing directories
+└── test-wp-rewriterules.sh - Bash script to test all WordPress rules using curl
+```
+
+## Apache Rules Explained
+
+### 1. HTTP Authorization Header Passing
+
+```apache
+RewriteEngine On
+RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+```
+
+**Что делает:** Копирует HTTP Authorization header из запроса в переменную `HTTP_AUTHORIZATION` для PHP
+
+**Зачем нужно:** WordPress REST API использует это для аутентификации через Bearer token
+
+**Пример использования:**
+```bash
+curl -H "Authorization: Bearer secret_token" http://site.com/wp-json/wp/v2/posts
+```
+
+### 2. RewriteBase Configuration
+
+```apache
+RewriteBase /
+```
+
+**Что делает:** Устанавливает базовый путь переписывания к корню сайта
+
+**Зачем нужно:** Определяет контекст для относительных путей в других правилах
+
+### 3. Direct index.php Access Protection
+
+```apache
+RewriteRule ^index\.php$ - [L]
+```
+
+**Что делает:** Если запрос идёт прямо на `index.php`, ничего не переписывает, останавливает процесс ([L] = Last)
+
+**Зачем нужно:** Предотвращает зацикливание маршрутизации
+
+### 4. WordPress Core Routing
+
+```apache
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteCond %{REQUEST_FILENAME} !-d
+RewriteRule . /index.php [L]
+```
+
+**Что делает:**
+- `!-f` - проверяет, что запрашиваемый файл НЕ существует
+- `!-d` - проверяет, что запрашиваемая директория НЕ существует  
+- Если оба условия true - маршрутизирует через `/index.php`
+
+**Зачем нужно:** WordPress использует "чистые URL" (permalinks), все запросы на несуществующие файлы/директории рутятся через index.php для обработки WP core
+
+## Test Script Features
+
+The script includes two test functions:
+1. `test_rule()` - checks HTTP status code only
+2. `test_rule_content()` - checks both status AND response body content
+
+## Test Coverage Summary
+
+### 1. HTTP_AUTHORIZATION Header ✓
+- REST API request with Authorization header → **200** + "WordPress Content Route" ✓
+
+### 2. RewriteBase Configuration ✓
+- Root directory access → **200** + "WordPress Content Route" ✓
+
+### 3. Direct index.php Access ✓
+- `/index.php` direct call → **200** (not rewritten) ✓
+
+### 4. WordPress Core Routing ✓
+- Non-existing file routes to `index.php` → **200** ✓
+- Existing file access (`existing.jpg`) → **200** ✓
+- Non-existing directory routes to `index.php` → **200** ✓
+- Existing directory access (`somedir/`) → **200** ✓
+
+## Run Tests
+
+Execute the test script to verify all rules:
+```bash
+cd /home/alexey/projects/workspace-zed/test1/cms/wordpress
+./test-wp-rewriterules.sh
+```
+
+Expected results (all should be **PASS ✓**):
+- Authorization header handling: HTTP 200 + content "WordPress Content Route" ✓
+- Base path routing: HTTP 200 + content "WordPress Content Route" ✓
+- Direct index.php access: HTTP 200 ✓
+- Non-existing file routing: HTTP 200 ✓
+- Existing file access: HTTP 200 ✓
+- Non-existing directory routing: HTTP 200 ✓
+- Directory access: HTTP 200 ✓
diff --git a/cms/wordpress/wordpress/existing.jpg b/cms/wordpress/wordpress/existing.jpg
new file mode 100644
index 0000000..e69de29
diff --git a/cms/wordpress/wordpress/index.php b/cms/wordpress/wordpress/index.php
new file mode 100644
index 0000000..4d46dfc
--- /dev/null
+++ b/cms/wordpress/wordpress/index.php
@@ -0,0 +1,15 @@
+<?php
+/**
+ * WordPress - index.php (Test version)
+ * This file handles routing for non-existing files/directories
+ */
+
+// Simulated WordPress response
+echo "<html><head><title>WordPress Test Site</title></head><body>";
+echo "<h1>WordPress Content Route</h1>";
+echo "<p>This page is served by index.php via RewriteRule.</p>";
+echo "<div class='wp-config'>WordPress Configuration Loaded</div>";
+echo "</body></html>";
+
+// Exit
+exit;
diff --git a/cms/wordpress/wordpress/somedir/.gitkeep b/cms/wordpress/wordpress/somedir/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/cms/wordpress/wordpress/wp_api.php b/cms/wordpress/wordpress/wp_api.php
new file mode 100644
index 0000000..80f40b5
--- /dev/null
+++ b/cms/wordpress/wordpress/wp_api.php
@@ -0,0 +1,54 @@
+<?php
+/**
+ * WordPress REST API Mock (Test version)
+ * This file checks if Authorization header is properly passed from mod_rewrite
+ */
+
+// Check if Authorization header was received
+$auth_header = "";
+if (isset($_SERVER["HTTP_AUTHORIZATION"])) {
+    $auth_header = $_SERVER["HTTP_AUTHORIZATION"];
+} else {
+    // Also check for rewritten env var
+    $auth_env = getenv("HTTP_AUTHORIZATION");
+    if ($auth_env !== false && $auth_env !== "") {
+        $auth_header = $auth_env;
+    }
+}
+
+// Set response headers
+header("Content-Type: application/json; charset=UTF-8");
+
+if ($auth_header === "secret_token_123") {
+    // SUCCESS - Authorization header was properly passed through mod_rewrite
+
+    echo json_encode(
+        [
+            "status" => "success",
+            "message" => "Authorization verified",
+            "token_verified" => true,
+            "wordpress_config_loaded" => true,
+            "received_auth_header" => $auth_header,
+        ],
+        JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES,
+    );
+} else {
+    // FAIL - Authorization header was not passed through mod_rewrite
+
+    http_response_code(401);
+
+    echo json_encode(
+        [
+            "status" => "error",
+            "message" => "unauth",
+            "expected" => "Bearer secret_token_123",
+            "received" => $auth_header ?: "(not set)",
+            "test_failed" => true,
+            "hint" =>
+                "mod_rewrite [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}] is NOT passing header to PHP",
+        ],
+        JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES,
+    );
+}
+
+exit();
diff --git a/modules/mod_rewrite/config b/modules/mod_rewrite/config
new file mode 100644
index 0000000..14976b1
--- /dev/null
+++ b/modules/mod_rewrite/config
@@ -0,0 +1,23 @@
+ngx_addon_name=ngx_http_apache_rewrite_module
+
+if test -n "$ngx_module_link"; then
+    ngx_module_type=HTTP
+    ngx_module_name=ngx_http_apache_rewrite_module
+    ngx_module_srcs="$ngx_addon_dir/ngx_http_apache_rewrite_module.c \
+                     $ngx_addon_dir/ngx_http_apache_rewrite_engine.c \
+                     $ngx_addon_dir/ngx_http_apache_rewrite_expand.c \
+                     $ngx_addon_dir/ngx_http_apache_rewrite_variable.c \
+                     $ngx_addon_dir/ngx_http_apache_rewrite_map.c \
+                     $ngx_addon_dir/ngx_http_apache_rewrite_fastcgi.c"
+    ngx_module_libs=
+    . auto/module
+else
+    HTTP_MODULES="$HTTP_MODULES ngx_http_apache_rewrite_module"
+    NGX_ADDON_SRCS="$NGX_ADDON_SRCS \
+                    $ngx_addon_dir/ngx_http_apache_rewrite_module.c \
+                    $ngx_addon_dir/ngx_http_apache_rewrite_engine.c \
+                    $ngx_addon_dir/ngx_http_apache_rewrite_expand.c \
+                    $ngx_addon_dir/ngx_http_apache_rewrite_variable.c \
+                    $ngx_addon_dir/ngx_http_apache_rewrite_map.c \
+                    $ngx_addon_dir/ngx_http_apache_rewrite_fastcgi.c"
+fi
diff --git a/modules/mod_rewrite/ngx_http_apache_rewrite_engine.c b/modules/mod_rewrite/ngx_http_apache_rewrite_engine.c
new file mode 100644
index 0000000..755a650
--- /dev/null
+++ b/modules/mod_rewrite/ngx_http_apache_rewrite_engine.c
@@ -0,0 +1,857 @@
+/*
+ * Copyright 2026 Alexey Berezhok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/*
+ * ngx_http_apache_rewrite_engine.c
+ *
+ * Core rewrite engine for nginx Apache mod_rewrite module.
+ * Ports apply_rewrite_list, apply_rewrite_rule, apply_rewrite_cond
+ * from Apache mod_rewrite.c.
+ */
+
+#include "ngx_http_apache_rewrite_engine.h"
+
+
+/*
+ * Check if a URI is absolute (has scheme://)
+ */
+ngx_int_t
+ngx_rewrite_is_absolute_uri(ngx_str_t *uri)
+{
+    u_char  *p, *end;
+
+    if (uri->len < 4) {
+        return 0;
+    }
+
+    p = uri->data;
+    end = p + uri->len;
+
+    /* Must start with alpha */
+    if (!((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z'))) {
+        return 0;
+    }
+
+    for (p++; p < end; p++) {
+        if (*p == ':') {
+            if (p + 2 < end && p[1] == '/' && p[2] == '/') {
+                return 1;
+            }
+            return 0;
+        }
+        if (!((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')
+              || (*p >= '0' && *p <= '9') || *p == '+' || *p == '-'
+              || *p == '.'))
+        {
+            return 0;
+        }
+    }
+
+    return 0;
+}
+
+
+/*
+ * Split query string out of a rewritten URI.
+ * Handles QSA (append), QSD (discard) flags.
+ */
+void
+ngx_rewrite_splitout_queryargs(ngx_http_request_t *r,
+    ngx_str_t *uri, ngx_int_t flags, ngx_str_t *args)
+{
+    u_char  *q;
+    u_char  *search_start;
+    u_char  *search_end;
+
+    if (flags & RULEFLAG_QSDISCARD) {
+        ngx_str_null(args);
+    }
+
+    search_start = uri->data;
+    search_end = uri->data + uri->len;
+
+    /* Find the question mark */
+    if (flags & RULEFLAG_QSLAST) {
+        /* Search from end */
+        q = NULL;
+        for (u_char *s = search_end - 1; s >= search_start; s--) {
+            if (*s == '?') {
+                q = s;
+                break;
+            }
+        }
+    } else {
+        /* Search from start */
+        q = ngx_strlchr(search_start, search_end, '?');
+    }
+
+    if (q == NULL) {
+        return;
+    }
+
+    /* Split: uri becomes everything before '?', args is after */
+    if (flags & RULEFLAG_QSAPPEND) {
+        /* Append new query string to existing */
+        if ((size_t)(search_end - q - 1) > 0) {
+            if (args->len > 0) {
+                u_char *combined;
+                size_t  new_len = (search_end - q - 1) + 1 + args->len;
+
+                combined = ngx_pnalloc(r->pool, new_len);
+                if (combined) {
+                    u_char *cp = combined;
+                    cp = ngx_cpymem(cp, q + 1, search_end - q - 1);
+                    *cp++ = '&';
+                    cp = ngx_cpymem(cp, args->data, args->len);
+                    args->data = combined;
+                    args->len = new_len;
+                }
+            } else {
+                args->data = q + 1;
+                args->len = search_end - q - 1;
+            }
+        }
+    } else if (!(flags & RULEFLAG_QSDISCARD)) {
+        args->data = q + 1;
+        args->len = search_end - q - 1;
+    }
+
+    uri->len = q - uri->data;
+}
+
+
+
+
+/*
+ * Apply a single RewriteCond.
+ * Port of Apache apply_rewrite_cond() (mod_rewrite.c:4120-4319).
+ */
+ngx_rewrite_cond_rc_e
+ngx_rewrite_apply_cond(ngx_rewrite_cond_t *cond, ngx_rewrite_ctx_t *ctx)
+{
+    ngx_str_t    input;
+    ngx_int_t    rc = COND_RC_NOMATCH;
+    ngx_int_t    n;
+    int          ovector[NGX_REWRITE_MAX_CAPTURES * 2];
+    ngx_file_info_t  fi;
+
+    /* Expand the condition input string */
+    input = ngx_rewrite_expand(&cond->input, ctx, NULL, ctx->r->pool);
+
+    switch (cond->ptype) {
+
+    case CONDPAT_FILE_EXISTS:
+        if (input.len > 0) {
+            u_char buf[NGX_MAX_PATH];
+            ngx_cpystrn(buf, input.data, ngx_min(input.len + 1, NGX_MAX_PATH));
+            if (ngx_file_info(buf, &fi) == NGX_FILE_ERROR) {
+                rc = COND_RC_NOMATCH;
+            } else if (ngx_is_file(&fi)) {
+                rc = COND_RC_MATCH;
+            }
+        }
+        break;
+
+    case CONDPAT_FILE_SIZE:
+        if (input.len > 0) {
+            u_char buf[NGX_MAX_PATH];
+            ngx_cpystrn(buf, input.data, ngx_min(input.len + 1, NGX_MAX_PATH));
+            if (ngx_file_info(buf, &fi) != NGX_FILE_ERROR
+                && ngx_is_file(&fi) && ngx_file_size(&fi) > 0)
+            {
+                rc = COND_RC_MATCH;
+            }
+        }
+        break;
+
+    case CONDPAT_FILE_DIR:
+        if (input.len > 0) {
+            u_char buf[NGX_MAX_PATH];
+            ngx_cpystrn(buf, input.data, ngx_min(input.len + 1, NGX_MAX_PATH));
+            if (ngx_file_info(buf, &fi) != NGX_FILE_ERROR
+                && ngx_is_dir(&fi))
+            {
+                rc = COND_RC_MATCH;
+            }
+        }
+        break;
+
+    case CONDPAT_FILE_LINK:
+        if (input.len > 0) {
+            u_char buf[NGX_MAX_PATH];
+            ngx_cpystrn(buf, input.data, ngx_min(input.len + 1, NGX_MAX_PATH));
+            if (ngx_file_info(buf, &fi) != NGX_FILE_ERROR
+                && ngx_is_link(&fi))
+            {
+                rc = COND_RC_MATCH;
+            }
+        }
+        break;
+
+    case CONDPAT_FILE_XBIT:
+        if (input.len > 0) {
+            u_char buf[NGX_MAX_PATH];
+            ngx_cpystrn(buf, input.data, ngx_min(input.len + 1, NGX_MAX_PATH));
+            if (ngx_file_info(buf, &fi) != NGX_FILE_ERROR
+                && (ngx_file_access(&fi) & 0111))
+            {
+                rc = COND_RC_MATCH;
+            }
+        }
+        break;
+
+    case CONDPAT_STR_LT:
+        rc = (ngx_memn2cmp(input.data, cond->pattern.data,
+                           input.len, cond->pattern.len) < 0)
+             ? COND_RC_MATCH : COND_RC_NOMATCH;
+        break;
+
+    case CONDPAT_STR_LE:
+        rc = (ngx_memn2cmp(input.data, cond->pattern.data,
+                           input.len, cond->pattern.len) <= 0)
+             ? COND_RC_MATCH : COND_RC_NOMATCH;
+        break;
+
+    case CONDPAT_STR_EQ:
+        if (cond->flags & CONDFLAG_NOCASE) {
+            rc = (input.len == cond->pattern.len
+                  && ngx_strncasecmp(input.data, cond->pattern.data,
+                                     input.len) == 0)
+                 ? COND_RC_MATCH : COND_RC_NOMATCH;
+        } else {
+            rc = (input.len == cond->pattern.len
+                  && ngx_memcmp(input.data, cond->pattern.data,
+                                input.len) == 0)
+                 ? COND_RC_MATCH : COND_RC_NOMATCH;
+        }
+        break;
+
+    case CONDPAT_STR_GT:
+        rc = (ngx_memn2cmp(input.data, cond->pattern.data,
+                           input.len, cond->pattern.len) > 0)
+             ? COND_RC_MATCH : COND_RC_NOMATCH;
+        break;
+
+    case CONDPAT_STR_GE:
+        rc = (ngx_memn2cmp(input.data, cond->pattern.data,
+                           input.len, cond->pattern.len) >= 0)
+             ? COND_RC_MATCH : COND_RC_NOMATCH;
+        break;
+
+    case CONDPAT_INT_LT:
+    case CONDPAT_INT_LE:
+    case CONDPAT_INT_EQ:
+    case CONDPAT_INT_GT:
+    case CONDPAT_INT_GE:
+        {
+            ngx_int_t  a, b;
+            u_char    *tmp;
+
+            /* null-terminate for ngx_atoi */
+            tmp = ngx_pnalloc(ctx->r->pool, input.len + 1);
+            if (tmp) {
+                ngx_memcpy(tmp, input.data, input.len);
+                tmp[input.len] = '\0';
+                a = ngx_atoi(input.data, input.len);
+            } else {
+                a = 0;
+            }
+            b = ngx_atoi(cond->pattern.data, cond->pattern.len);
+
+            if (a == NGX_ERROR) a = 0;
+            if (b == NGX_ERROR) b = 0;
+
+            switch (cond->ptype) {
+            case CONDPAT_INT_LT: rc = (a < b);  break;
+            case CONDPAT_INT_LE: rc = (a <= b); break;
+            case CONDPAT_INT_EQ: rc = (a == b); break;
+            case CONDPAT_INT_GT: rc = (a > b);  break;
+            case CONDPAT_INT_GE: rc = (a >= b); break;
+            default: break;
+            }
+        }
+        break;
+
+    default:
+        /* CONDPAT_REGEX — regular expression match */
+        if (cond->regex == NULL) {
+            break;
+        }
+
+        n = ngx_regex_exec(cond->regex, &input,
+                           ovector, NGX_REWRITE_MAX_CAPTURES * 2);
+
+        if (n >= 0) {
+            rc = COND_RC_MATCH;
+
+            /* Store condition backrefs (%N) */
+            if (!(cond->flags & CONDFLAG_NOTMATCH)) {
+                ctx->briRC.source = input;
+                ngx_memcpy(ctx->briRC.ovector, ovector, sizeof(ovector));
+                ctx->briRC.ncaptures = (n > 0) ? n : NGX_REWRITE_MAX_CAPTURES;
+            }
+        }
+        break;
+    }
+
+    /* Handle negation */
+    if (cond->flags & CONDFLAG_NOTMATCH) {
+        rc = !rc;
+    }
+
+    ngx_log_debug4(NGX_LOG_DEBUG_HTTP, ctx->r->connection->log, 0,
+                   "mod_rewrite: RewriteCond input=\"%V\" pattern=\"%V\" "
+                   "%s => %s",
+                   &input, &cond->pattern,
+                   (cond->flags & CONDFLAG_NOCASE) ? "[NC]" : "",
+                   rc ? "matched" : "not-matched");
+
+    return rc ? COND_RC_MATCH : COND_RC_NOMATCH;
+}
+
+
+/*
+ * Apply a single RewriteRule.
+ * Port of Apache apply_rewrite_rule() (mod_rewrite.c:4359-4641).
+ */
+ngx_rewrite_rule_rc_e
+ngx_rewrite_apply_rule(ngx_rewrite_rule_t *rule, ngx_rewrite_ctx_t *ctx, ngx_str_t baseurl, ngx_int_t baseurl_set)
+{
+    int                     ovector[NGX_REWRITE_MAX_CAPTURES * 2];
+    ngx_int_t               n, rc;
+    ngx_rewrite_cond_t     *conds;
+    ngx_uint_t              i;
+    ngx_str_t               newuri;
+    ngx_http_request_t     *r = ctx->r;
+
+    /* Match the URI against the rule pattern */
+    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "mod_rewrite: applying pattern \"%V\" to uri \"%V\"",
+                   &rule->pattern, &ctx->uri);
+
+    if (rule->regex == NULL) {
+        return RULE_RC_NOMATCH;
+    }
+
+    n = ngx_regex_exec(rule->regex, &ctx->match_uri,
+                       ovector, NGX_REWRITE_MAX_CAPTURES * 2);
+
+    rc = (n >= 0) ? 1 : 0;
+
+    /* Check match/notmatch */
+    if (!((rc && !(rule->flags & RULEFLAG_NOTMATCH))
+          || (!rc && (rule->flags & RULEFLAG_NOTMATCH))))
+    {
+        return RULE_RC_NOMATCH;
+    }
+
+    /* Rule matched — prepare backref context */
+    ngx_str_null(&ctx->briRC.source);
+    ctx->briRC.ncaptures = 0;
+
+    if (rule->flags & RULEFLAG_NOTMATCH) {
+        ngx_str_null(&ctx->briRR.source);
+        ctx->briRR.ncaptures = 0;
+    } else {
+        ctx->briRR.source.data = ngx_pnalloc(r->pool, ctx->uri.len);
+        if (ctx->briRR.source.data) {
+            ngx_memcpy(ctx->briRR.source.data, ctx->match_uri.data, ctx->match_uri.len);
+            ctx->briRR.source.len = ctx->match_uri.len;
+        }
+        ngx_memcpy(ctx->briRR.ovector, ovector, sizeof(ovector));
+        ctx->briRR.ncaptures = (n > 0) ? n : NGX_REWRITE_MAX_CAPTURES;
+    }
+
+    /* Evaluate conditions (AND/OR logic) */
+    if (rule->conditions && rule->conditions->nelts > 0) {
+        conds = rule->conditions->elts;
+
+        for (i = 0; i < rule->conditions->nelts; i++) {
+            ngx_rewrite_cond_t *c = &conds[i];
+
+            rc = ngx_rewrite_apply_cond(c, ctx);
+
+            if (c->flags & CONDFLAG_ORNEXT) {
+                if (!rc) {
+                    /* OR: this one failed, try next */
+                    continue;
+                } else {
+                    /* OR: this one matched, skip remaining OR chain */
+                    while (i < rule->conditions->nelts
+                           && conds[i].flags & CONDFLAG_ORNEXT)
+                    {
+                        i++;
+                    }
+                }
+            } else if (!rc) {
+                /* AND: condition failed — rule does not match */
+                return RULE_RC_NOMATCH;
+            }
+        }
+    }
+
+    /* Handle environment variables (E=var:val) */
+    if (rule->env) {
+        ngx_rewrite_data_item_t *env = rule->env;
+        while (env) {
+            ngx_str_t expanded;
+            u_char   *colon;
+
+            expanded = ngx_rewrite_expand(&env->data, ctx, rule, r->pool);
+
+            if (expanded.len > 0 && expanded.data[0] == '!') {
+                /* Unset: not directly supported in nginx, skip */
+            } else {
+                colon = ngx_strlchr(expanded.data,
+                                    expanded.data + expanded.len, ':');
+                if (colon) {
+                    ngx_str_t vname, vval;
+                    (void)vval;
+
+                    vname.data = expanded.data;
+                    vname.len = colon - expanded.data;
+                    vval.data = colon + 1;
+                    vval.len = expanded.len - vname.len - 1;
+
+                    /* Store in context for FastCGI integration */
+                    if (ctx->env_vars == NULL) {
+                        ctx->env_vars = ngx_palloc(r->pool,
+                            sizeof(ngx_rewrite_data_item_t));
+                        ctx->env_vars->next = NULL;
+                        ctx->env_vars->data.data = ngx_pnalloc(r->pool, expanded.len);
+                        if (ctx->env_vars->data.data) {
+                            ngx_memcpy(ctx->env_vars->data.data, expanded.data, expanded.len);
+                            ctx->env_vars->data.len = expanded.len;
+                        } else {
+                            /* Memory allocation failed - continue without tracking */
+                        }
+                    } else {
+                        /* Append to list */
+                        ngx_rewrite_data_item_t *new_env = ngx_palloc(r->pool,
+                            sizeof(ngx_rewrite_data_item_t));
+                        if (new_env) {
+                            new_env->data.data = ngx_pnalloc(r->pool, expanded.len);
+                            if (new_env->data.data) {
+                                ngx_memcpy(new_env->data.data, expanded.data, expanded.len);
+                                new_env->data.len = expanded.len;
+                            } else {
+                                /* Memory allocation failed */
+                                new_env = NULL;
+                            }
+                            new_env->next = ctx->env_vars;
+                            if (new_env) {
+                                ctx->env_vars = new_env;
+                            }
+                        }
+                    }
+
+                    ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                                   "mod_rewrite: [E=...] set \"%*s\" => \"%*s\"",
+                                   vname.len, vname.data, vval.len, vval.data);
+                }
+            }
+
+            env = env->next;
+        }
+    }
+
+    /* No-substitution rule (pattern '-') */
+    if (rule->flags & RULEFLAG_NOSUB) {
+        if (rule->flags & RULEFLAG_STATUS) {
+            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                           "mod_rewrite: forcing status %d (nosub)",
+                           rule->forced_responsecode);
+        }
+        return RULE_RC_NOSUB;
+    }
+
+    /* Expand the substitution */
+    newuri = ngx_rewrite_expand(&rule->output, ctx, rule, r->pool);
+
+    ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "mod_rewrite: rewrite \"%V\" -> \"%V\" (flags=0x%xd, code=%d)",
+                   &ctx->uri, &newuri, rule->flags, rule->forced_responsecode);
+
+    /* Split out query string */
+    {
+        ngx_str_t  new_args = r->args;
+        ngx_rewrite_splitout_queryargs(r, &newuri, rule->flags, &new_args);
+        r->args = new_args;
+    }
+
+    /* Check for absolute URI → redirect */
+    if (rule->flags & RULEFLAG_FORCEREDIRECT) {
+        /* Explicit redirect [R] or [R=NNN] */
+        ngx_int_t code = rule->forced_responsecode;
+        if (code == 0) {
+            code = NGX_HTTP_MOVED_TEMPORARILY;
+        }
+
+        /* Fully qualify if needed */
+        if (!ngx_rewrite_is_absolute_uri(&newuri)) {
+            ngx_str_t  scheme, host;
+            ngx_uint_t port;
+            u_char    *p;
+            size_t     len;
+
+#if (NGX_SSL)
+            if (r->connection->ssl) {
+                ngx_str_set(&scheme, "https");
+                port = 443;
+            } else
+#endif
+            {
+                ngx_str_set(&scheme, "http");
+                port = 80;
+            }
+
+            ngx_http_core_loc_conf_t  *clcf;
+            clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+            /* Use r->headers_in.server if available (has been sanitized - no port) */
+            if (clcf->server_name_in_redirect || r->headers_in.server.len > 0) {
+                if (clcf->server_name_in_redirect) {
+                    ngx_http_core_srv_conf_t *cscf;
+                    cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
+                    host = cscf->server_name;
+                } else {
+                    host = r->headers_in.server;
+                }
+            } else {
+                ngx_http_core_srv_conf_t *cscf;
+                cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
+                host = cscf->server_name;
+            }
+
+            {
+                ngx_uint_t actual_port;
+                actual_port = ngx_inet_get_port(r->connection->local_sockaddr);
+                if (actual_port == port) {
+                    port = 0;
+                } else {
+                    port = actual_port;
+                }
+            }
+
+            len = scheme.len + 3 + host.len + newuri.len + 3;
+            if (port) {
+                len += 6; /* :NNNNN */
+            }
+            if (baseurl_set) {
+                len += baseurl.len;
+            }
+
+            p = ngx_pnalloc(r->pool, len);
+            if (p) {
+                u_char *start = p;
+                p = ngx_cpymem(p, scheme.data, scheme.len);
+                *p++ = ':'; *p++ = '/'; *p++ = '/';
+                p = ngx_cpymem(p, host.data, host.len);
+                if (port) {
+                    p = ngx_sprintf(p, ":%ui", port);
+                }
+                if (baseurl_set && baseurl.len > 0) {
+                    if (baseurl.data[0] == '/')
+                        p = ngx_cpymem(p, baseurl.data, baseurl.len);
+                    else {
+                        *p++ = '/';
+                        p = ngx_cpymem(p, baseurl.data, baseurl.len);
+                    }
+                }
+                if (*(p-1)!='/' && newuri.data[0]!= '/') {
+                    *p++ = '/';
+                }
+                p = ngx_cpymem(p, newuri.data, newuri.len);
+                newuri.data = start;
+                newuri.len = p - start;
+            }
+        }
+
+        ctx->redirect_url = newuri;
+        ctx->redirect_code = code;
+        ctx->uri = newuri;
+        return RULE_RC_MATCH;
+    }
+
+    /* Check for implicit redirect (absolute URI in substitution) */
+    if (ngx_rewrite_is_absolute_uri(&newuri)) {
+        ngx_int_t code = rule->forced_responsecode;
+        if (code == 0) {
+            code = NGX_HTTP_MOVED_TEMPORARILY;
+        }
+
+        ctx->redirect_url = newuri;
+        ctx->redirect_code = code;
+        ctx->uri = newuri;
+        return RULE_RC_MATCH;
+    }
+
+    /* Ensure URI starts with '/' */
+    if (newuri.len == 0 || newuri.data[0] != '/') {
+        if (ctx->htaccess.data){
+            u_char *p = ngx_pcalloc(r->pool, ctx->htaccess.len + newuri.len + 4);
+            if (p){
+                *p = '/';
+                u_char *p1 = p + 1;
+                if (ctx->htaccess.len > 0){
+                    ngx_memcpy(p1, ctx->htaccess.data, ctx->htaccess.len);
+                    p1 = p1 + ctx->htaccess.len;
+                    if (ctx->htaccess.data[ctx->htaccess.len-1] != '/') {
+                        *p1 = '/';
+                        p1++;
+                    }
+                }
+                if (newuri.len > 0) {
+                    ngx_memcpy(p1, newuri.data, newuri.len);
+                    p1 = p1 + newuri.len;
+                }
+                newuri.data = p;
+                newuri.len = p1 - p;
+            }
+        } else {
+            u_char *p = ngx_pcalloc(r->pool, newuri.len + 1);
+            if (p) {
+                *p = '/';
+                if (newuri.len > 0) {
+                    ngx_memcpy(p + 1, newuri.data, newuri.len);
+                }
+                newuri.data = p;
+                newuri.len++;
+            }
+        }
+    }
+
+    ctx->uri = newuri;
+    ngx_str_null(&ctx->redirect_url);
+    ctx->redirect_code = 0;
+
+    return RULE_RC_MATCH;
+}
+
+static void
+ngx_rewrite_save_skip_flag(void *cln)
+{
+    /* cleanup handler - не используется, просто метка */
+}
+
+ngx_int_t
+ngx_rewrite_set_skip_after_redirect(ngx_http_request_t *r)
+{
+    ngx_pool_cleanup_t     *cln;
+    ngx_rewrite_pool_ctx_t  *pctx = NULL;
+    for (cln = r->pool->cleanup; cln; cln = cln->next) {
+        if (cln->handler == ngx_rewrite_save_skip_flag) {
+            pctx = cln->data;
+            break;
+        }
+    }
+
+    if (!pctx) {
+    cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_rewrite_pool_ctx_t));
+        if (cln == NULL) {
+            return NGX_ERROR;
+        }
+        pctx = cln->data;
+    }
+
+    /* Сохраняем флаг и текущий URI */
+    pctx->skip_rewrite_after_redirect = 1;
+
+    cln->handler = ngx_rewrite_save_skip_flag; /* просто метка */
+    return NGX_OK;
+}
+
+
+/*
+ * Apply a complete list of rewrite rules.
+ * Port of Apache apply_rewrite_list() (mod_rewrite.c:4647-4817).
+ *
+ * Returns: 0 = no change, ACTION_NORMAL/ACTION_NOESCAPE = changed,
+ *          ACTION_STATUS = status set.
+ */
+ngx_int_t
+ngx_rewrite_apply_list(ngx_http_request_t *r, ngx_array_t *rules,
+    ngx_str_t *htaccess, ngx_str_t baseurl, ngx_int_t baseurl_set)
+{
+    ngx_rewrite_rule_t    *entries;
+    ngx_rewrite_rule_t    *p;
+    ngx_uint_t             i;
+    ngx_int_t              changed = 0;
+    ngx_rewrite_rule_rc_e  rc;
+    ngx_int_t              round = 1;
+    ngx_rewrite_ctx_t     *ctx;
+    ngx_pool_cleanup_t     *cln;
+    ngx_rewrite_pool_ctx_t *pctx;
+
+    if (r->internal) {
+        for (cln = r->pool->cleanup; cln; cln = cln->next) {
+            if (cln->handler == ngx_rewrite_save_skip_flag) {
+                pctx = cln->data;
+                if (pctx && pctx->skip_rewrite_after_redirect) {
+                    pctx->skip_rewrite_after_redirect = 0;
+                    /* Skip rewriting on redirected URI */
+                    return 0;
+                }
+            }
+        }
+    }
+
+    if (rules == NULL || rules->nelts == 0) {
+        return 0;
+    }
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+    if (ctx == NULL) {
+        ctx = ngx_pcalloc(r->pool, sizeof(ngx_rewrite_ctx_t));
+        if (ctx == NULL) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+        ngx_http_set_ctx(r, ctx, ngx_http_apache_rewrite_module);
+    }
+
+    /* Check END flag from previous invocation */
+    if (ctx->end) {
+        return 0;
+    }
+
+    ctx->r = r;
+    ctx->uri = r->uri;
+    ctx->match_uri = r->uri;
+    ctx->uri_changed = 0;
+
+    ctx->htaccess = ((htaccess) ? (*htaccess) : (ngx_str_t)ngx_null_string);
+
+    if (ctx->htaccess.data && ctx->match_uri.len > 1 && ctx->match_uri.data[0] == '/') {
+        ngx_str_t tmp_str = ngx_null_string;
+        // Allocate buffer for relative URI (strip htaccess directory prefix)
+        if (r->uri.len > (size_t)(ctx->htaccess.len + 1)) {
+            tmp_str.data = ngx_pnalloc(r->pool, r->uri.len - ctx->htaccess.len + 1);
+            if (tmp_str.data != NULL) {
+                // Strip the htaccess directory prefix to get relative URI for pattern matching
+                // Example: /wordpress/wp-json/ -> /wp-json/ when htaccess=/wordpress
+                ngx_memcpy(tmp_str.data, r->uri.data + ctx->htaccess.len + 1,
+                           r->uri.len - ctx->htaccess.len - 1);
+                tmp_str.len = r->uri.len - (ctx->htaccess.len + 1);
+                ctx->match_uri = tmp_str;
+            } else {
+                // Fallback: use original URI on allocation failure
+                ctx->match_uri = r->uri;
+            }
+        }
+    } else {
+        // Use original URI for matching when htaccess not applicable
+        ctx->match_uri = r->uri;
+    }
+    ngx_str_null(&ctx->redirect_url);
+    ctx->redirect_code = 0;
+
+    entries = rules->elts;
+
+loop:
+    for (i = 0; i < rules->nelts; i++) {
+        p = &entries[i];
+
+        /* Skip on subrequests if NS flag or redirect */
+        if (r->main != r
+            && (p->flags & (RULEFLAG_IGNOREONSUBREQ | RULEFLAG_FORCEREDIRECT)))
+        {
+            continue;
+        }
+
+        /* Apply this rule */
+        rc = ngx_rewrite_apply_rule(p, ctx, baseurl, baseurl_set);
+
+        if (rc != RULE_RC_NOMATCH) {
+            /* Check for status set */
+            if (rc == RULE_RC_STATUS_SET) {
+                return ACTION_STATUS_SET;
+            }
+
+            /* Status flag [F], [G], or [R=NNN] with nosub */
+            if (p->flags & RULEFLAG_STATUS) {
+                ctx->status_code = p->forced_responsecode;
+                return ACTION_STATUS;
+            }
+
+            /* Track changes for non-nosub rules */
+            if (rc != RULE_RC_NOSUB) {
+                changed = (p->flags & RULEFLAG_NOESCAPE)
+                          ? ACTION_NOESCAPE : ACTION_NORMAL;
+            }
+
+            /* PassThrough [PT] — let other handlers process */
+            if (p->flags & RULEFLAG_PASSTHROUGH) {
+                r->uri = ctx->uri;
+                ctx->uri_changed = 1;
+                changed = ACTION_NORMAL;
+                break;
+            }
+
+            /* END flag */
+            if (p->flags & RULEFLAG_END) {
+                ctx->end = 1;
+                break;
+            }
+
+            /* Last rule [L] or proxy [P] */
+            if (p->flags & (RULEFLAG_LASTRULE | RULEFLAG_PROXY)) {
+                break;
+            }
+
+            /* New round [N] */
+            if (p->flags & RULEFLAG_NEWROUND) {
+                ngx_int_t maxrounds = p->maxrounds;
+                if (maxrounds == 0) {
+                    maxrounds = NGX_REWRITE_MAX_ROUNDS;
+                }
+
+                if (++round >= maxrounds) {
+                    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
+                        "mod_rewrite: RewriteRule \"%V\" and URI \"%V\" "
+                        "exceeded maximum number of rounds (%d) "
+                        "via the [N] flag",
+                        &p->pattern, &r->uri, maxrounds);
+                    return ACTION_STATUS;
+                }
+
+                /* Update r->uri for next round */
+                r->uri = ctx->uri;
+                ctx->uri_changed = 1;
+                goto loop;
+            }
+
+            /* Skip [S=N] */
+            if (p->skip > 0) {
+                ngx_int_t s = p->skip;
+                while (i < rules->nelts && s > 0) {
+                    i++;
+                    s--;
+                }
+            }
+
+            /* Chain [C] — continue to next rule */
+        } else {
+            /* No match: if chained, skip rest of chain */
+            while (i < rules->nelts && (p->flags & RULEFLAG_CHAIN)) {
+                i++;
+                if (i < rules->nelts) {
+                    p = &entries[i];
+                }
+            }
+        }
+    }
+
+    /* Update r->uri if changed */
+    if (changed && ctx->uri.len > 0 && ctx->redirect_url.len == 0) {
+        r->uri = ctx->uri;
+        ctx->uri_changed = 1;
+    }
+
+    return changed;
+}
diff --git a/modules/mod_rewrite/ngx_http_apache_rewrite_engine.h b/modules/mod_rewrite/ngx_http_apache_rewrite_engine.h
new file mode 100644
index 0000000..8caef96
--- /dev/null
+++ b/modules/mod_rewrite/ngx_http_apache_rewrite_engine.h
@@ -0,0 +1,332 @@
+/*
+ * Copyright 2026 Alexey Berezhok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/*
+ * ngx_http_apache_rewrite_engine.h
+ *
+ * Shared header for the nginx Apache mod_rewrite compatibility module.
+ * Contains all data structures, constants, and function prototypes.
+ */
+
+#ifndef _NGX_HTTP_APACHE_REWRITE_ENGINE_H_
+#define _NGX_HTTP_APACHE_REWRITE_ENGINE_H_
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_http.h>
+
+/*
+ * Maximum regex captures (matches AP_MAX_REG_MATCH = 10)
+ */
+#define NGX_REWRITE_MAX_CAPTURES    10
+
+/*
+ * Maximum rounds for [N] flag loop prevention
+ */
+#define NGX_REWRITE_MAX_ROUNDS      10000
+
+/*
+ * RewriteEngine state
+ */
+#define ENGINE_DISABLED             (1 << 0)
+#define ENGINE_ENABLED              (1 << 1)
+
+/*
+ * RewriteOptions flags
+ */
+#define OPTION_NONE                 (1 << 0)
+#define OPTION_INHERIT              (1 << 1)
+#define OPTION_INHERIT_BEFORE       (1 << 2)
+
+/*
+ * RewriteRule flags
+ */
+#define RULEFLAG_NONE               (1 << 0)
+#define RULEFLAG_FORCEREDIRECT      (1 << 1)
+#define RULEFLAG_LASTRULE           (1 << 2)
+#define RULEFLAG_NEWROUND           (1 << 3)
+#define RULEFLAG_CHAIN              (1 << 4)
+#define RULEFLAG_IGNOREONSUBREQ     (1 << 5)
+#define RULEFLAG_NOTMATCH           (1 << 6)
+#define RULEFLAG_PROXY              (1 << 7)
+#define RULEFLAG_PASSTHROUGH        (1 << 8)
+#define RULEFLAG_QSAPPEND           (1 << 9)
+#define RULEFLAG_NOCASE             (1 << 10)
+#define RULEFLAG_NOESCAPE           (1 << 11)
+#define RULEFLAG_NOSUB              (1 << 12)
+#define RULEFLAG_STATUS             (1 << 13)
+#define RULEFLAG_ESCAPEBACKREF      (1 << 14)
+#define RULEFLAG_DISCARDPATHINFO    (1 << 15)
+#define RULEFLAG_QSDISCARD          (1 << 16)
+#define RULEFLAG_END                (1 << 17)
+#define RULEFLAG_QSLAST             (1 << 19)
+
+/*
+ * Return codes for apply_rewrite_list
+ */
+#define ACTION_NORMAL               (1 << 0)
+#define ACTION_NOESCAPE             (1 << 1)
+#define ACTION_STATUS               (1 << 2)
+#define ACTION_STATUS_SET           (1 << 3)
+
+/*
+ * RewriteCond flags
+ */
+#define CONDFLAG_NONE               (1 << 0)
+#define CONDFLAG_NOCASE             (1 << 1)
+#define CONDFLAG_NOTMATCH           (1 << 2)
+#define CONDFLAG_ORNEXT             (1 << 3)
+
+/*
+ * Condition pattern types
+ */
+typedef enum {
+    CONDPAT_REGEX = 0,
+    CONDPAT_FILE_EXISTS,
+    CONDPAT_FILE_SIZE,
+    CONDPAT_FILE_LINK,
+    CONDPAT_FILE_DIR,
+    CONDPAT_FILE_XBIT,
+    CONDPAT_STR_LT,
+    CONDPAT_STR_LE,
+    CONDPAT_STR_EQ,
+    CONDPAT_STR_GT,
+    CONDPAT_STR_GE,
+    CONDPAT_INT_LT,
+    CONDPAT_INT_LE,
+    CONDPAT_INT_EQ,
+    CONDPAT_INT_GT,
+    CONDPAT_INT_GE
+} ngx_rewrite_condpat_type_e;
+
+/*
+ * Rule return types
+ */
+typedef enum {
+    RULE_RC_NOMATCH = 0,
+    RULE_RC_MATCH = 1,
+    RULE_RC_NOSUB = 2,
+    RULE_RC_STATUS_SET = 3
+} ngx_rewrite_rule_rc_e;
+
+/*
+ * Condition return types
+ */
+typedef enum {
+    COND_RC_NOMATCH = 0,
+    COND_RC_MATCH = 1
+} ngx_rewrite_cond_rc_e;
+
+/*
+ * Map types
+ */
+#define MAPTYPE_TXT                 (1 << 0)
+#define MAPTYPE_INT                 (1 << 3)
+#define MAPTYPE_RND                 (1 << 4)
+#define MAPTYPE_PRG                 (1 << 2)
+
+/*
+ * Backreference info — stores match source + capture offsets
+ */
+typedef struct {
+    ngx_str_t    source;
+    int          ovector[NGX_REWRITE_MAX_CAPTURES * 2];
+    ngx_int_t    ncaptures;
+} ngx_rewrite_backref_t;
+
+/*
+ * Single linked list for env vars (E=var:val)
+ */
+typedef struct ngx_rewrite_data_item_s ngx_rewrite_data_item_t;
+struct ngx_rewrite_data_item_s {
+    ngx_rewrite_data_item_t  *next;
+    ngx_str_t                 data;
+};
+
+/*
+ * RewriteCond entry
+ */
+typedef struct {
+    ngx_str_t                     input;       /* input string */
+    ngx_str_t                     pattern;     /* pattern string */
+    ngx_regex_t                  *regex;       /* compiled regex (if regex type) */
+    ngx_int_t                     flags;       /* CONDFLAG_* */
+    ngx_rewrite_condpat_type_e    ptype;       /* pattern type */
+} ngx_rewrite_cond_t;
+
+/*
+ * RewriteRule entry
+ */
+typedef struct {
+    ngx_str_t                     pattern;      /* regex pattern string */
+    ngx_regex_t                  *regex;        /* compiled regex */
+    ngx_str_t                     output;       /* substitution string */
+    ngx_int_t                     flags;        /* RULEFLAG_* */
+    ngx_array_t                  *conditions;   /* array of ngx_rewrite_cond_t */
+    ngx_int_t                     skip;         /* S=N skip count */
+    ngx_int_t                     maxrounds;    /* N=limit */
+    ngx_int_t                     forced_responsecode; /* R=NNN */
+    ngx_rewrite_data_item_t      *env;          /* E=var:val list */
+    ngx_str_t                     forced_mimetype; /* T=type */
+} ngx_rewrite_rule_t;
+
+/*
+ * htaccess cache linked list entry
+ */
+typedef struct htaccess_entry_s {
+    u_char        *file_path;           /* full path to .htaccess file (string) */
+    time_t        mtime;                /* last modification time */
+    ngx_array_t  *rules;                /* array of ngx_rewrite_rule_t */
+    ngx_str_t       baseurl;
+    ngx_int_t       options;
+    ngx_int_t       state;
+    unsigned        state_set:1;
+    unsigned        options_set:1;
+    unsigned        baseurl_set:1;
+    ngx_str_t       fallback_path;      /* RewriteFallBack path from .htaccess */
+    struct htaccess_entry_s *next;      /* linked list next pointer */
+} htaccess_entry_t;
+
+/*
+ * Map entry
+ */
+typedef struct {
+    ngx_str_t   name;
+    ngx_int_t   type;             /* MAPTYPE_* */
+    ngx_str_t   source;           /* filename or function name for int */
+    ngx_str_t (*func)(ngx_pool_t *pool, ngx_str_t key);
+} ngx_rewrite_map_entry_t;
+
+/*
+ * Per-server configuration
+ */
+typedef struct {
+    ngx_int_t       state;        /* ENGINE_DISABLED | ENGINE_ENABLED */
+    ngx_int_t       options;
+    ngx_array_t    *rules;        /* array of ngx_rewrite_rule_t */
+    ngx_array_t    *pending_conds;/* temp: conditions before next rule */
+    ngx_array_t    *maps;         /* array of ngx_rewrite_map_entry_t */
+    unsigned        state_set:1;
+    unsigned        options_set:1;
+    ngx_int_t       htaccess_enable;      // 0|1: enable htaccess parsing
+    ngx_str_t       htaccess_name;        // file name (default ".htaccess")
+    unsigned        htaccess_enable_set:1;
+    unsigned        htaccess_name_set:1;
+
+    /* Fallback to index.php with query string after try_files miss */
+    ngx_int_t       fallback_to_index;    // 0|1: enable fallback mechanism
+    unsigned        fallback_to_index_set:1;
+} ngx_http_apache_rewrite_srv_conf_t;
+
+/*
+ * Per-location configuration
+ */
+typedef struct {
+    ngx_int_t       state;        /* ENGINE_DISABLED | ENGINE_ENABLED */
+    ngx_int_t       options;
+    ngx_array_t    *rules;        /* array of ngx_rewrite_rule_t */
+    ngx_array_t    *pending_conds;/* temp: conditions before next rule */
+    ngx_str_t       baseurl;      /* RewriteBase */
+    unsigned        state_set:1;
+    unsigned        options_set:1;
+    unsigned        baseurl_set:1;
+    ngx_str_t       fallback_path;  /* RewriteFallBack path from .htaccess */
+} ngx_http_apache_rewrite_loc_conf_t;
+
+/*
+ * Per-request context (stored via ngx_http_set_ctx / ngx_http_get_module_ctx)
+ */
+typedef struct {
+    ngx_http_request_t   *r;
+    ngx_str_t             uri;      /* current URI being matched */
+    ngx_str_t             match_uri;
+    ngx_str_t             htaccess;
+    ngx_rewrite_backref_t briRR;    /* rule backrefs ($N) */
+    ngx_rewrite_backref_t briRC;    /* condition backrefs (%N) */
+    unsigned              end:1;    /* END flag set — stop all rewriting */
+    ngx_str_t             redirect_url; /* for external redirects */
+    ngx_int_t             redirect_code;
+    ngx_int_t             status_code;  /* forced status from [F], [G], etc. */
+    htaccess_entry_t     *htaccess_cache_head;  /* head of linked list of cached entries */
+
+    /* Fallback path - from RewriteFallBack in .htaccess or default /index.php */
+    ngx_str_t             fallback_path;
+
+    /* Environment variables set by [E=VAR:VAL] flags */
+    /* These persist across request phases for FastCGI integration */
+    ngx_rewrite_data_item_t   *env_vars;
+    ngx_int_t             uri_changed;
+} ngx_rewrite_ctx_t;
+
+/* modules/mod_rewrite/ngx_http_apache_rewrite_pool_ctx.h */
+typedef struct {
+    ngx_flag_t             skip_rewrite_after_redirect; /* флаг пропуска rewrite */
+} ngx_rewrite_pool_ctx_t;
+
+/*
+ * htaccess pool cleanup context - stores cached entries when request ctx is cleared
+ */
+typedef struct {
+    htaccess_entry_t     *htaccess_cache_entries_head;  /* head of linked list of cached entries (saved in pool) */
+} ngx_htaccess_pool_cleanup_ctx_t;
+
+/*
+ * Module extern
+ */
+extern ngx_module_t ngx_http_apache_rewrite_module;
+
+
+/* --- Engine functions (ngx_http_apache_rewrite_engine.c) --- */
+
+ngx_int_t ngx_rewrite_apply_list(ngx_http_request_t *r,
+    ngx_array_t *rules, ngx_str_t *htaccess, ngx_str_t baseurl, ngx_int_t baseurl_set);
+
+ngx_rewrite_rule_rc_e ngx_rewrite_apply_rule(ngx_rewrite_rule_t *rule,
+    ngx_rewrite_ctx_t *ctx, ngx_str_t baseurl, ngx_int_t baseurl_set);
+
+ngx_rewrite_cond_rc_e ngx_rewrite_apply_cond(ngx_rewrite_cond_t *cond,
+    ngx_rewrite_ctx_t *ctx);
+
+void ngx_rewrite_splitout_queryargs(ngx_http_request_t *r,
+    ngx_str_t *uri, ngx_int_t flags, ngx_str_t *args);
+
+ngx_int_t ngx_rewrite_is_absolute_uri(ngx_str_t *uri);
+
+
+/* --- Expand functions (ngx_http_apache_rewrite_expand.c) --- */
+
+ngx_str_t ngx_rewrite_expand(ngx_str_t *input, ngx_rewrite_ctx_t *ctx,
+    ngx_rewrite_rule_t *rule, ngx_pool_t *pool);
+
+
+/* --- Variable functions (ngx_http_apache_rewrite_variable.c) --- */
+
+ngx_str_t ngx_rewrite_lookup_variable(ngx_str_t *var,
+    ngx_rewrite_ctx_t *ctx);
+
+
+/* --- Map functions (ngx_http_apache_rewrite_map.c) --- */
+
+ngx_str_t ngx_rewrite_lookup_map(ngx_http_request_t *r,
+    ngx_http_apache_rewrite_srv_conf_t *sconf,
+    ngx_str_t *mapname, ngx_str_t *key);
+
+ngx_str_t ngx_rewrite_map_tolower(ngx_pool_t *pool, ngx_str_t key);
+ngx_str_t ngx_rewrite_map_toupper(ngx_pool_t *pool, ngx_str_t key);
+ngx_str_t ngx_rewrite_map_escape(ngx_pool_t *pool, ngx_str_t key);
+ngx_str_t ngx_rewrite_map_unescape(ngx_pool_t *pool, ngx_str_t key);
+
+/* reuest cache functions */
+
+ngx_int_t
+ngx_rewrite_set_skip_after_redirect(ngx_http_request_t *r);
+
+
+#endif /* _NGX_HTTP_APACHE_REWRITE_ENGINE_H_ */
diff --git a/modules/mod_rewrite/ngx_http_apache_rewrite_expand.c b/modules/mod_rewrite/ngx_http_apache_rewrite_expand.c
new file mode 100644
index 0000000..34a0520
--- /dev/null
+++ b/modules/mod_rewrite/ngx_http_apache_rewrite_expand.c
@@ -0,0 +1,337 @@
+/*
+ * Copyright 2026 Alexey Berezhok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/*
+ * ngx_http_apache_rewrite_expand.c
+ *
+ * String expansion for Apache mod_rewrite substitutions.
+ * Handles: \\x (escape), $N (rule backrefs), %N (cond backrefs),
+ *          %{VARNAME} (variables), ${MAP:KEY|DEFAULT} (map lookups).
+ */
+
+#include "ngx_http_apache_rewrite_engine.h"
+
+
+/*
+ * Result fragment linked list for efficient string building.
+ */
+typedef struct ngx_rewrite_result_s  ngx_rewrite_result_t;
+
+struct ngx_rewrite_result_s {
+    ngx_rewrite_result_t  *next;
+    u_char                *data;
+    size_t                 len;
+};
+
+#define SMALL_EXPANSION  5
+
+
+/*
+ * Find closing curly brace with nesting support.
+ */
+static u_char *
+ngx_rewrite_find_closing_curly(u_char *s, u_char *end)
+{
+    ngx_uint_t depth = 1;
+
+    for (; s < end; s++) {
+        if (*s == '}') {
+            if (--depth == 0) {
+                return s;
+            }
+        } else if (*s == '{') {
+            depth++;
+        }
+    }
+
+    return NULL;
+}
+
+
+/*
+ * Find a character inside curly braces (at depth 1).
+ */
+static u_char *
+ngx_rewrite_find_char_in_curlies(u_char *s, u_char *end, u_char c)
+{
+    ngx_uint_t depth = 1;
+
+    for (; s < end; s++) {
+        if (*s == c && depth == 1) {
+            return s;
+        }
+        if (*s == '}') {
+            if (--depth == 0) {
+                return NULL;
+            }
+        } else if (*s == '{') {
+            depth++;
+        }
+    }
+
+    return NULL;
+}
+
+
+/*
+ * Expand a substitution string.
+ *
+ * Port of Apache do_expand() (mod_rewrite.c:2417-2677).
+ * Single-pass expansion for security.
+ */
+ngx_str_t
+ngx_rewrite_expand(ngx_str_t *input, ngx_rewrite_ctx_t *ctx,
+    ngx_rewrite_rule_t *rule, ngx_pool_t *pool)
+{
+    ngx_str_t                          result_str;
+    ngx_rewrite_result_t               sresult[SMALL_EXPANSION];
+    ngx_rewrite_result_t              *result, *current;
+    ngx_uint_t                         spc = 0;
+    u_char                            *p, *inp_end, *c;
+    size_t                             span, outlen;
+    ngx_http_apache_rewrite_srv_conf_t *sconf;
+
+    if (input->len == 0) {
+        ngx_str_null(&result_str);
+        return result_str;
+    }
+
+    inp_end = input->data + input->len;
+
+    /* Find first special character */
+    for (p = input->data; p < inp_end; p++) {
+        if (*p == '\\' || *p == '$' || *p == '%') {
+            break;
+        }
+    }
+
+    span = p - input->data;
+
+    /* Fast path: no specials */
+    if (p >= inp_end) {
+        result_str.data = ngx_pnalloc(pool, input->len);
+        if (result_str.data == NULL) {
+            ngx_str_null(&result_str);
+            return result_str;
+        }
+        ngx_memcpy(result_str.data, input->data, input->len);
+        result_str.len = input->len;
+        return result_str;
+    }
+
+    /* Initialize result list */
+    result = current = &sresult[spc++];
+    current->next = NULL;
+    current->data = input->data;
+    current->len = span;
+    outlen = span;
+
+    /* Process specials */
+    do {
+        /* Advance to next node if current has content */
+        if (current->len) {
+            if (spc < SMALL_EXPANSION) {
+                current->next = &sresult[spc++];
+            } else {
+                current->next = ngx_palloc(pool,
+                                           sizeof(ngx_rewrite_result_t));
+                if (current->next == NULL) {
+                    ngx_str_null(&result_str);
+                    return result_str;
+                }
+            }
+            current = current->next;
+            current->next = NULL;
+            current->len = 0;
+        }
+
+        /* Escaped character: \x → literal x */
+        if (*p == '\\') {
+            current->len = 1;
+            outlen++;
+            p++;
+            if (p >= inp_end) {
+                current->data = p - 1;
+                break;
+            }
+            current->data = p;
+            p++;
+        }
+
+        /* Variable or map lookup: %{...} or ${...} */
+        else if (p + 1 < inp_end && p[1] == '{') {
+            u_char *endp;
+
+            endp = ngx_rewrite_find_closing_curly(p + 2, inp_end);
+            if (endp == NULL) {
+                /* No closing brace, copy literally */
+                current->len = 2;
+                current->data = p;
+                outlen += 2;
+                p += 2;
+            }
+            /* %{VARNAME} — variable lookup */
+            else if (*p == '%') {
+                ngx_str_t vname, val;
+
+                vname.data = p + 2;
+                vname.len = endp - (p + 2);
+                val = ngx_rewrite_lookup_variable(&vname, ctx);
+
+                current->len = val.len;
+                current->data = val.data;
+                outlen += val.len;
+                p = endp + 1;
+            }
+            /* ${MAP:KEY|DEFAULT} — map lookup */
+            else { /* *p == '$' */
+                u_char *key_start;
+
+                key_start = ngx_rewrite_find_char_in_curlies(p + 2, endp, ':');
+                if (key_start == NULL) {
+                    /* No colon, copy literally */
+                    current->len = 2;
+                    current->data = p;
+                    outlen += 2;
+                    p += 2;
+                } else {
+                    ngx_str_t map_name, map_key, map_dflt, map_result;
+                    ngx_str_t key_expanded;
+                    u_char *dflt_start;
+
+                    map_name.data = p + 2;
+                    map_name.len = key_start - (p + 2);
+
+                    key_start++; /* skip ':' */
+
+                    /* Find default separator '|' */
+                    dflt_start = ngx_rewrite_find_char_in_curlies(
+                        key_start, endp, '|');
+
+                    if (dflt_start) {
+                        map_key.data = key_start;
+                        map_key.len = dflt_start - key_start;
+                        map_dflt.data = dflt_start + 1;
+                        map_dflt.len = endp - (dflt_start + 1);
+                    } else {
+                        map_key.data = key_start;
+                        map_key.len = endp - key_start;
+                        ngx_str_null(&map_dflt);
+                    }
+
+                    /* Recursively expand the key */
+                    key_expanded = ngx_rewrite_expand(&map_key, ctx,
+                                                      rule, pool);
+
+                    sconf = ngx_http_get_module_srv_conf(ctx->r,
+                        ngx_http_apache_rewrite_module);
+
+                    map_result = ngx_rewrite_lookup_map(ctx->r, sconf,
+                        &map_name, &key_expanded);
+
+                    if (map_result.len == 0 && map_dflt.len > 0) {
+                        map_result = ngx_rewrite_expand(&map_dflt, ctx,
+                                                        rule, pool);
+                    }
+
+                    current->len = map_result.len;
+                    current->data = map_result.data;
+                    outlen += map_result.len;
+                    p = endp + 1;
+                }
+            }
+        }
+
+        /* Backreference: $N or %N */
+        else if (p + 1 < inp_end
+                 && p[1] >= '0' && p[1] <= '9')
+        {
+            ngx_int_t n = p[1] - '0';
+            ngx_rewrite_backref_t *bri;
+
+            if (*p == '$') {
+                bri = &ctx->briRR;
+            } else {
+                bri = &ctx->briRC;
+            }
+
+            if (bri->source.data
+                && n < bri->ncaptures
+                && bri->ovector[n * 2] >= 0
+                && bri->ovector[n * 2 + 1] > bri->ovector[n * 2])
+            {
+                span = bri->ovector[n * 2 + 1] - bri->ovector[n * 2];
+                current->len = span;
+                current->data = bri->source.data + bri->ovector[n * 2];
+                outlen += span;
+            }
+
+            p += 2;
+        }
+
+        /* Not a special, copy literally */
+        else {
+            current->len = 1;
+            current->data = p;
+            outlen++;
+            p++;
+        }
+
+        /* Find next stretch of non-special characters */
+        if (p < inp_end) {
+            u_char *start = p;
+            while (p < inp_end && *p != '\\' && *p != '$' && *p != '%') {
+                p++;
+            }
+            span = p - start;
+            if (span > 0) {
+                if (current->len) {
+                    if (spc < SMALL_EXPANSION) {
+                        current->next = &sresult[spc++];
+                    } else {
+                        current->next = ngx_palloc(pool,
+                            sizeof(ngx_rewrite_result_t));
+                        if (current->next == NULL) {
+                            ngx_str_null(&result_str);
+                            return result_str;
+                        }
+                    }
+                    current = current->next;
+                    current->next = NULL;
+                }
+                current->data = start;
+                current->len = span;
+                outlen += span;
+            }
+        }
+
+    } while (p < inp_end);
+
+    /* Assemble result */
+    c = ngx_pnalloc(pool, outlen);
+    if (c == NULL) {
+        ngx_str_null(&result_str);
+        return result_str;
+    }
+
+    result_str.data = c;
+    result_str.len = outlen;
+
+    current = result;
+    while (current) {
+        if (current->len) {
+            ngx_memcpy(c, current->data, current->len);
+            c += current->len;
+        }
+        current = current->next;
+    }
+
+    return result_str;
+}
diff --git a/modules/mod_rewrite/ngx_http_apache_rewrite_fastcgi.c b/modules/mod_rewrite/ngx_http_apache_rewrite_fastcgi.c
new file mode 100644
index 0000000..f2b4ecf
--- /dev/null
+++ b/modules/mod_rewrite/ngx_http_apache_rewrite_fastcgi.c
@@ -0,0 +1,387 @@
+/*
+ * Copyright 2026 Alexey Berezhok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/*
+ * ngx_http_apache_rewrite_fastcgi.c
+ *
+ * FastCGI integration for Apache mod_rewrite module.
+ * Passes environment variables set by [E=VAR:VAL] flags in RewriteRule
+ * to PHP/FastCGI contexts via nginx variables.
+ *
+ * This file provides:
+ * - ngx_rewrite_get_env_var() - lookup function for env vars
+ * - ngx_rewrite_create_env_variable() - register custom variable handler
+ * - Automatic passing mechanism to FastCGI params (auto mode)
+ */
+
+#include "ngx_http_apache_rewrite_engine.h"
+
+
+/* ============================================================
+ * Environment Variable Storage in Context
+ * ============================================================ */
+struct ngx_rewrite_env_ctx_s {
+    ngx_str_t           env_value;   /* Final value for this request context */
+};
+
+
+/*
+ * Custom variable handler for E=VAR:VAL variables.
+ * Returns the value from ctx->env_vars list.
+ */
+static ngx_int_t __attribute__((unused))
+ngx_rewrite_env_variable_handler(ngx_http_request_t *r,
+    ngx_http_variable_value_t *v, void *data)
+{
+    ngx_rewrite_ctx_t  *ctx;
+
+    v->valid = 1;
+    v->no_cacheable = 0;
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+
+    if (!ctx || !ctx->env_vars) {
+        v->not_found = 1;
+        return NGX_OK;
+    }
+
+    /* Lookup by name */
+    u_char *colon;
+    const char *var_name = (const char *)v->data;
+    size_t var_name_len = v->len;
+
+    ngx_rewrite_data_item_t  *env = ctx->env_vars;
+    while (env) {
+        if (!env->data.data || env->data.len == 0) {
+            env = env->next;
+            continue;
+        }
+
+        /* Check format VAR:VAL */
+        colon = ngx_strlchr(env->data.data,
+                            (u_char *)(env->data.data + env->data.len), ':');
+
+        if (!colon) {
+            env = env->next;
+            continue;
+        }
+
+        size_t name_len = colon - env->data.data;
+        u_char *var_name_lowered = ngx_pnalloc(r->pool, var_name_len);
+        for (size_t i = 0; i < var_name_len; i++) {
+            var_name_lowered[i] = ngx_tolower(var_name[i]);
+        }
+
+        /* Compare names case-insensitively */
+        if ((name_len == var_name_len &&
+            ngx_strncmp((char *)colon + 1, (char *)var_name_lowered, name_len) == 0) ||
+            strcmp((const char *)(env->data.data), var_name) == 0) {
+
+            /* Found matching env var */
+            u_char *p = v->data;
+            while (*p != ':' && p < v->data + v->len) {
+                p++;
+            }
+
+            if (p < v->data + v->len) {
+                /* Extract value after colon */
+                size_t value_len = env->data.len - name_len - 1;
+                const u_char *value_start = colon + 1;
+                u_char *value_copy = ngx_pnalloc(r->pool, value_len);
+                if (!value_copy) {
+                    v->not_found = 1;
+                    return NGX_OK;
+                }
+
+                ngx_memcpy(value_copy, value_start, value_len);
+
+                v->data = (u_char *)value_copy;
+                v->len = value_len;
+                return NGX_OK;
+            }
+        }
+
+        env = env->next;
+    }
+
+    /* Not found */
+    v->not_found = 1;
+    return NGX_OK;
+}
+
+
+/*
+ * Register a custom variable from E=VAR:VAL format.
+ * Creates nginx variable $var_name and links to handler.
+ */
+ngx_int_t
+ngx_rewrite_create_env_variable(ngx_http_request_t *r,
+    const char *name, size_t name_len, const u_char *value, size_t value_len)
+{
+    ngx_str_t           vname;
+    ngx_uint_t          key;
+
+    /* Create nginx variable name: $var_name */
+    vname.len = name_len + 1;  /* +1 for '$' prefix */
+    vname.data = (u_char *)ngx_palloc(r->pool, vname.len + 1);
+    if (!vname.data) {
+        return NGX_ERROR;
+    }
+
+    vname.data[0] = '$';
+    ngx_memcpy(vname.data + 1, name, name_len);
+    /* Remove underscores for nginx var format (HTTP_AUTH -> http-auth) */
+    for (size_t i = 1; i < vname.len; i++) {
+        if (vname.data[i] == '_') {
+            vname.data[i] = '-';
+        } else {
+            vname.data[i] = ngx_tolower(vname.data[i]);
+        }
+    }
+
+    /* Calculate hash */
+    key = ngx_hash_strlow(vname.data, vname.data, vname.len);
+
+    /* Lookup/create variable */
+    ngx_http_variable_value_t  *vv;
+    vv = ngx_http_get_variable(r, &vname, key);
+
+    if (!vv) {
+        /* Variable doesn't exist - this shouldn't happen normally */
+        return NGX_ERROR;
+    }
+
+    /* Set the value */
+    vv->data = (u_char *)value;
+    vv->len = value_len;
+    vv->valid = 1;
+    vv->no_cacheable = 0;
+    vv->not_found = 0;
+
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "mod_rewrite-fastcgi: Created variable \"%V\"", &vname);
+
+    return NGX_OK;
+}
+
+
+/* ============================================================
+ * Lookup Functions for Downstream Modules (e.g., FastCGI)
+ * ============================================================ */
+
+/**
+ * Get an environment variable set by mod_rewrite [E=...] flag.
+ * Returns the value or null if not found/invalid.
+ */
+ngx_str_t
+ngx_rewrite_get_env_var(ngx_http_request_t *r, const char *name, size_t name_len)
+{
+    ngx_uint_t          key;
+    ngx_str_t           vname;
+    ngx_http_variable_value_t  *vv;
+
+    /* Lookup by name - handle underscores to dashes */
+    u_char *lowered = ngx_pnalloc(r->pool, name_len + 1);
+    for (size_t i = 0; i < name_len; i++) {
+        lowered[i] = ngx_tolower(name[i]);
+    }
+
+    vname.data = lowered;
+    vname.len = name_len;
+    key = ngx_hash_strlow(vname.data, vname.data, vname.len);
+
+    vv = ngx_http_get_variable(r, &vname, key);
+
+    if (!vv || vv->not_found) {
+        /* Variable not found */
+        return (ngx_str_t){ 0, NULL };
+    }
+
+    /* Return a copy since we can't guarantee the data persists */
+    ngx_str_t result;
+    result.len = vv->len;
+    result.data = ngx_pnalloc(r->pool, vv->len);
+    if (!result.data) {
+        return (ngx_str_t){ 0, NULL };
+    }
+
+    ngx_memcpy(result.data, vv->data, vv->len);
+
+    return result;
+}
+
+
+/**
+ * Convert ALL environment variables from mod_rewrite to HTTP headers.
+ * This is called in CONTENT_PHASE handler to pass E vars to FastCGI/PHP.
+ *
+ * Apache PHP sees $_SERVER['HTTP_*'] for all HTTP headers automatically.
+ * So we convert E=VAR:VAL -> HTTP header r->headers_in.VAR
+ */
+ngx_int_t
+ngx_rewrite_add_env_as_headers(ngx_http_request_t *r)
+{
+    ngx_rewrite_ctx_t  *ctx;
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+
+    if (!ctx || !ctx->env_vars) {
+        /* No env vars from mod_rewrite - nothing to convert */
+        return NGX_OK;
+    }
+
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "mod_rewrite-http-headers: Converting E-vars from ctx");
+
+    /* Iterate over all environment variables */
+    ngx_rewrite_data_item_t  *env = ctx->env_vars;
+
+    while (env) {
+        u_char   *colon;
+
+        if (!env->data.data || env->data.len == 0) {
+            env = env->next;
+            continue;
+        }
+
+        /* Split VAR:VAL */
+        colon = ngx_strlchr(env->data.data,
+                            (u_char *)(env->data.data + env->data.len), ':');
+
+        if (!colon) {
+            /* No colon - invalid format, skip */
+            env = env->next;
+            continue;
+        }
+
+        size_t var_name_len = colon - env->data.data;
+        const u_char *value_start = colon + 1;
+
+        ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "mod_rewrite-http-headers: E-var \"%*s\" => \"%*s\"",
+                       var_name_len, env->data.data,
+                       env->data.len - var_name_len - 1, value_start);
+
+        /* Convert header names for PHP access via $_SERVER['HTTP_*']
+         * Apache behavior: E=VAR sets environment variable VAR.
+         * FastCGI/PHP sees it as $_SERVER[VAR].
+         * For HTTP_* headers (like HTTP_AUTHORIZATION), we need to set them correctly. */
+
+        u_char *header_name;
+        size_t header_len;
+
+        /* Check if the var already starts with "HTTP_" - don't double-prefix */
+        if (var_name_len >= 5 && ngx_strncasecmp(env->data.data, (u_char *)"HTTP_", 5) == 0) {
+            /* Already HTTP_* format - use as-is for $_SERVER[HTTP_*] */
+            header_name = ngx_pnalloc(r->pool, var_name_len + 1);
+            if (!header_name) {
+                return NGX_ERROR;
+            }
+
+            /* Copy VAR name and convert to uppercase with underscores */
+            for (size_t j = 0; j < var_name_len; j++) {
+                char ch = ((char *)env->data.data)[j];
+                if (ch == '-') {
+                    header_name[j] = '_';
+                } else {
+                    header_name[j] = ngx_toupper(ch);
+                }
+            }
+
+            /* Set without HTTP_ prefix since already has it */
+            header_len = var_name_len;
+        } else {
+            /* Need to add HTTP_ prefix for non-HTTP vars */
+            header_name = ngx_pnalloc(r->pool, var_name_len + 6);
+            if (!header_name) {
+                return NGX_ERROR;
+            }
+
+            size_t i = 0;
+            header_name[i++] = 'H';
+            header_name[i++] = 'T';
+            header_name[i++] = 'T';
+            header_name[i++] = 'P';
+            header_name[i++] = '_';
+
+            /* Copy VAR name and convert to uppercase with underscores */
+            for (size_t j = 0; j < var_name_len; j++) {
+                char ch = ((char *)env->data.data)[j];
+                if (ch == '-') {
+                    header_name[i++] = '_';
+                } else {
+                    header_name[i] = ngx_toupper(ch);
+                    i++;
+                }
+            }
+
+            header_len = i;
+        }
+
+        /* Create HTTP_* header entry */
+        u_char *header_value_copy = ngx_pnalloc(r->pool, env->data.len - var_name_len - 1 + 1);
+        if (!header_value_copy) {
+            return NGX_ERROR;
+        }
+
+        ngx_memcpy(header_value_copy, value_start, env->data.len - var_name_len - 1);
+        header_value_copy[env->data.len - var_name_len - 1] = '\0';
+
+        /* Add header to r->headers_in */
+        ngx_table_elt_t *h = ngx_list_push(&r->headers_in.headers);
+        if (!h) {
+            return NGX_ERROR;
+        }
+
+        h->hash = 1;
+        h->key.len = header_len;
+        h->key.data = header_name;
+        h->value.len = env->data.len - var_name_len - 1;
+        h->value.data = header_value_copy;
+
+        ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "mod_rewrite-http-headers: Added HTTP header \"%*s\" => \"%*s\"",
+                       header_len, header_name, h->value.len, h->value.data);
+
+        env = env->next;
+    }
+
+    return NGX_OK;
+}
+
+
+/* ============================================================
+ * Module Hooks (Registered via postconfiguration)
+ * ============================================================ */
+
+/**
+ * Register handlers for fastcgi phase integration.
+ * This is called during module initialization.
+ */
+ngx_int_t
+ngx_http_apache_rewrite_fastcgi_register(ngx_http_request_t *r)
+{
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "mod_rewrite-fastcgi: Auto-integration mode enabled");
+
+    return NGX_OK;
+}
+
+
+/* ============================================================
+ * Public API Export Header
+ * ============================================================ */
+
+/* These functions can be called from other modules or nginx config directives */
+extern ngx_str_t ngx_rewrite_get_env_var(ngx_http_request_t *r, const char *name, size_t name_len);
+extern ngx_int_t ngx_rewrite_create_env_variable(ngx_http_request_t *r,
+    const char *name, size_t name_len, const u_char *value, size_t value_len);
+
+extern ngx_int_t ngx_rewrite_add_env_as_headers(ngx_http_request_t *r);
diff --git a/modules/mod_rewrite/ngx_http_apache_rewrite_fastcgi.h b/modules/mod_rewrite/ngx_http_apache_rewrite_fastcgi.h
new file mode 100644
index 0000000..0e24ab2
--- /dev/null
+++ b/modules/mod_rewrite/ngx_http_apache_rewrite_fastcgi.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2026 Alexey Berezhok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/*
+ * ngx_http_apache_rewrite_fastcgi.h
+ *
+ * FastCGI integration header for Apache mod_rewrite compatibility module.
+ */
+
+#ifndef _NGX_HTTP_APACHE_REWRITE_FASTCGI_H_
+#define _NGX_HTTP_APACHE_REWRITE_FASTCGI_H_
+
+#include <ngx_core.h>
+#include <ngx_http.h>
+
+
+/* ============================================================
+ * Public API Functions
+ * ============================================================ */
+
+/**
+ * Lookup an environment variable set by [E=VAR:VAL] flag.
+ * Returns the value or ngx_null_string if not found.
+ *
+ * @param r nginx request
+ * @param name variable name (e.g., "HTTP_AUTHORIZATION")
+ * @param name_len length of name
+ * @return ngx_str_t containing the value, or ngx_null_string on failure
+ */
+extern ngx_str_t ngx_rewrite_get_env_var(ngx_http_request_t *r, const char *name, size_t name_len);
+
+
+/**
+ * Create/register a custom variable for FastCGI.
+ * Sets up nginx variable $var_name with given value.
+ *
+ * @param r nginx request
+ * @param name variable name (without prefix)
+ * @param name_len length of name
+ * @param value value string to set
+ * @param value_len length of value
+ * @return NGX_OK on success, NGX_ERROR on failure
+ */
+extern ngx_int_t ngx_rewrite_create_env_variable(ngx_http_request_t *r,
+    const char *name, size_t name_len, const u_char *value, size_t value_len);
+
+
+/**
+ * Automatically add ALL [E=...] environment variables as HTTP headers.
+ * Called in CONTENT_PHASE to pass vars without manual nginx config.
+ * PHP/FastCGI will see these as $_SERVER['HTTP_*'] automatically.
+ *
+ * @param r nginx request containing ctx->env_vars
+ * @return NGX_OK on success, NGX_ERROR on failure
+ */
+
+extern ngx_int_t ngx_rewrite_add_env_as_headers(ngx_http_request_t *r);
+
+
+/**
+ * Register module hooks for FastCGI integration.
+ * Called during postconfiguration.
+ *
+ * @param cf nginx configuration context
+ * @return NGX_OK on success, NGX_ERROR on failure
+ */
+extern ngx_int_t ngx_http_apache_rewrite_fastcgi_register(ngx_http_request_t *r);
+
+
+/* ============================================================
+ * Compile-time Options
+ * ============================================================ */
+
+/* Enable FastCGI integration - defines NGX_FASTCGI_INTEGRATION_ENABLED in module.c */
+#define NGX_FASTCGI_INTEGRATION_ENABLED   1
+
+/* Mark ngx_http_fastcgi_module.h as available (defined by nginx core) */
+#ifdef NGX_HTTP_FASTCGI_MODULE
+#define NGX_FASTCGI_MODULE_PRESENT    1
+#endif
+
+
+#endif /* _NGX_HTTP_APACHE_REWRITE_FASTCGI_H_ */
diff --git a/modules/mod_rewrite/ngx_http_apache_rewrite_map.c b/modules/mod_rewrite/ngx_http_apache_rewrite_map.c
new file mode 100644
index 0000000..3fd05dd
--- /dev/null
+++ b/modules/mod_rewrite/ngx_http_apache_rewrite_map.c
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2026 Alexey Berezhok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/*
+ * ngx_http_apache_rewrite_map.c
+ *
+ * RewriteMap implementations for nginx Apache rewrite module.
+ * Phase 1: internal functions (tolower, toupper, escape, unescape).
+ * Phase 2 will add txt, rnd, prg maps (if needed).
+ */
+
+#include "ngx_http_apache_rewrite_engine.h"
+
+
+/*
+ * int:tolower — convert string to lowercase
+ */
+ngx_str_t
+ngx_rewrite_map_tolower(ngx_pool_t *pool, ngx_str_t key)
+{
+    ngx_str_t  result;
+    u_char    *p;
+
+    result.data = ngx_pnalloc(pool, key.len);
+    if (result.data == NULL) {
+        ngx_str_null(&result);
+        return result;
+    }
+
+    result.len = key.len;
+    for (p = result.data; key.len--; ) {
+        *p++ = ngx_tolower(*key.data++);
+    }
+
+    return result;
+}
+
+
+/*
+ * int:toupper — convert string to uppercase
+ */
+ngx_str_t
+ngx_rewrite_map_toupper(ngx_pool_t *pool, ngx_str_t key)
+{
+    ngx_str_t  result;
+    u_char    *p;
+    ngx_uint_t i;
+
+    result.data = ngx_pnalloc(pool, key.len);
+    if (result.data == NULL) {
+        ngx_str_null(&result);
+        return result;
+    }
+
+    result.len = key.len;
+    p = result.data;
+    for (i = 0; i < key.len; i++) {
+        u_char ch = key.data[i];
+        if (ch >= 'a' && ch <= 'z') {
+            ch -= 32;
+        }
+        *p++ = ch;
+    }
+
+    return result;
+}
+
+
+/*
+ * int:escape — percent-encode string (URI-safe encoding)
+ */
+ngx_str_t
+ngx_rewrite_map_escape(ngx_pool_t *pool, ngx_str_t key)
+{
+    ngx_str_t  result;
+    uintptr_t  escaped_len;
+
+    escaped_len = ngx_escape_uri(NULL, key.data, key.len,
+                                 NGX_ESCAPE_ARGS);
+    result.len = key.len + 2 * escaped_len;
+    result.data = ngx_pnalloc(pool, result.len);
+    if (result.data == NULL) {
+        ngx_str_null(&result);
+        return result;
+    }
+
+    if (escaped_len) {
+        ngx_escape_uri(result.data, key.data, key.len, NGX_ESCAPE_ARGS);
+    } else {
+        ngx_memcpy(result.data, key.data, key.len);
+    }
+
+    return result;
+}
+
+
+/*
+ * int:unescape — percent-decode string
+ */
+ngx_str_t
+ngx_rewrite_map_unescape(ngx_pool_t *pool, ngx_str_t key)
+{
+    ngx_str_t  result;
+    u_char    *dst;
+
+    result.data = ngx_pnalloc(pool, key.len + 1);
+    if (result.data == NULL) {
+        ngx_str_null(&result);
+        return result;
+    }
+
+    dst = result.data;
+    ngx_memcpy(dst, key.data, key.len);
+    dst[key.len] = '\0';
+
+    ngx_unescape_uri(&dst, &result.data, key.len, 0);
+    /* After unescape, dst points past written data, result.data is start */
+    /* Actually ngx_unescape_uri modifies both pointers. Re-do properly: */
+    result.data = ngx_pnalloc(pool, key.len + 1);
+    if (result.data == NULL) {
+        ngx_str_null(&result);
+        return result;
+    }
+
+    ngx_memcpy(result.data, key.data, key.len);
+    result.data[key.len] = '\0';
+
+    dst = result.data;
+    {
+        u_char *src = result.data;
+        ngx_unescape_uri(&dst, &src, key.len, 0);
+    }
+    result.len = dst - result.data;
+
+    return result;
+}
+
+
+/*
+ * Lookup a named map and return the value for the given key.
+ * In Phase 1, only internal (int:) maps are supported.
+ */
+ngx_str_t
+ngx_rewrite_lookup_map(ngx_http_request_t *r,
+    ngx_http_apache_rewrite_srv_conf_t *sconf,
+    ngx_str_t *mapname, ngx_str_t *key)
+{
+    ngx_str_t                  result = ngx_null_string;
+    ngx_rewrite_map_entry_t   *maps;
+    ngx_uint_t                 i;
+
+    if (sconf == NULL || sconf->maps == NULL || sconf->maps->nelts == 0) {
+        return result;
+    }
+
+    maps = sconf->maps->elts;
+    for (i = 0; i < sconf->maps->nelts; i++) {
+        if (maps[i].name.len == mapname->len
+            && ngx_strncasecmp(maps[i].name.data, mapname->data,
+                               mapname->len) == 0)
+        {
+            if (maps[i].type == MAPTYPE_INT && maps[i].func) {
+                result = maps[i].func(r->pool, *key);
+            }
+            /* txt, rnd, prg maps — Phase 2 */
+            break;
+        }
+    }
+
+    return result;
+}
diff --git a/modules/mod_rewrite/ngx_http_apache_rewrite_module.c b/modules/mod_rewrite/ngx_http_apache_rewrite_module.c
new file mode 100644
index 0000000..0b0141b
--- /dev/null
+++ b/modules/mod_rewrite/ngx_http_apache_rewrite_module.c
@@ -0,0 +1,2676 @@
+/*
+ * Copyright 2026 Alexey Berezhok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/*
+ * ngx_http_apache_rewrite_module.c
+ *
+ * Main nginx module file for Apache mod_rewrite compatibility.
+ * Provides directives: RewriteEngine, RewriteRule, RewriteCond,
+ *                      RewriteBase, RewriteOptions, RewriteMap
+ *
+ * Registers phase handlers for SERVER_REWRITE and REWRITE phases.
+ */
+
+#include "ngx_http_apache_rewrite_engine.h"
+
+/* FastCGI integration header (if available) */
+#include "ngx_http_apache_rewrite_fastcgi.h"
+
+
+/* Forward declarations */
+static void *ngx_http_apache_rewrite_create_srv_conf(ngx_conf_t *cf);
+static char *ngx_http_apache_rewrite_merge_srv_conf(ngx_conf_t *cf,
+    void *parent, void *child);
+static void *ngx_http_apache_rewrite_create_loc_conf(ngx_conf_t *cf);
+static char *ngx_http_apache_rewrite_merge_loc_conf(ngx_conf_t *cf,
+    void *parent, void *child);
+static ngx_int_t ngx_http_apache_rewrite_postconfiguration(ngx_conf_t *cf);
+
+static char *ngx_http_rewrite_engine(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+static char *ngx_http_rewrite_rule(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+static char *ngx_http_rewrite_cond(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+static char *ngx_http_rewrite_base(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+static char *ngx_http_rewrite_options(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+static char *ngx_http_rewrite_map(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+
+static char *ngx_http_htaccess_enable(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+static char *ngx_http_htaccess_name(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+static char *ngx_http_fallback_to_index(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+
+static void ngx_htaccess_update_cache(ngx_http_request_t *r, ngx_str_t file_path, time_t mtime, ngx_http_apache_rewrite_loc_conf_t *parsed_rules);
+static ngx_htaccess_pool_cleanup_ctx_t *ngx_htaccess_get_from_pool_cleanup(ngx_http_request_t *r);
+static htaccess_entry_t *ngx_htaccess_create_in_pool_cleanup(ngx_http_request_t *r, ngx_str_t file_path, time_t mtime,
+    ngx_http_apache_rewrite_loc_conf_t *parsed_rules, ngx_htaccess_pool_cleanup_ctx_t *pool);
+static void ngx_htaccess_cleanup(void *data);
+static ngx_http_apache_rewrite_loc_conf_t * ngx_htaccess_parse_file_from_ha(ngx_http_request_t *r, ngx_str_t *file_path);
+static void ngx_rewrite_strip_brackets(ngx_str_t *s);
+static ngx_int_t ngx_htaccess_build_path(ngx_http_request_t *r, u_char *docroot, size_t docroot_len,
+    ngx_str_t *path, u_char *htaccess_name, size_t htaccess_len);
+static ngx_int_t ngx_htaccess_search_upward(ngx_http_request_t *r, u_char *docroot, size_t docroot_len, ngx_str_t *current_path,
+    u_char *htaccess_name, size_t htaccess_name_len, ngx_str_t *found_path);
+
+static ngx_int_t ngx_http_apache_rewrite_server_handler(
+    ngx_http_request_t *r);
+static ngx_int_t ngx_http_apache_rewrite_location_handler(
+    ngx_http_request_t *r);
+
+static ngx_int_t
+ngx_http_apache_rewrite_url_register_hook_with_fallback(ngx_http_request_t *r);
+
+/* --- Flag parsing helpers --- */
+
+static ngx_int_t ngx_http_rewrite_parse_rule_flags(ngx_pool_t *pool,
+    ngx_str_t *flags_str, ngx_rewrite_rule_t *rule);
+static ngx_int_t ngx_http_rewrite_parse_cond_flags(ngx_conf_t *cf,
+    ngx_str_t *flags_str, ngx_rewrite_cond_t *cond);
+
+
+/*
+ * Directives
+ */
+static ngx_command_t ngx_http_apache_rewrite_commands[] = {
+
+    { ngx_string("RewriteEngine"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_http_rewrite_engine,
+      0,
+      0,
+      NULL },
+
+    { ngx_string("RewriteRule"),
+      NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE23,
+      ngx_http_rewrite_rule,
+      0,
+      0,
+      NULL },
+
+    { ngx_string("RewriteCond"),
+      NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE23,
+      ngx_http_rewrite_cond,
+      0,
+      0,
+      NULL },
+
+    { ngx_string("RewriteBase"),
+      NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+      ngx_http_rewrite_base,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      0,
+      NULL },
+
+    { ngx_string("RewriteOptions"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
+      ngx_http_rewrite_options,
+      0,
+      0,
+      NULL },
+
+    { ngx_string("RewriteMap"),
+      NGX_HTTP_SRV_CONF|NGX_CONF_TAKE2,
+      ngx_http_rewrite_map,
+      NGX_HTTP_SRV_CONF_OFFSET,
+      0,
+      NULL },
+
+    { ngx_string("HtaccessEnable"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
+      ngx_http_htaccess_enable,
+      0,
+      0,
+      NULL },
+
+    { ngx_string("HtaccessName"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
+      ngx_http_htaccess_name,
+      0,
+      0,
+      NULL },
+
+    { ngx_string("FallbackToIndex"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
+      ngx_http_fallback_to_index,
+      0,
+      0,
+      NULL },
+
+    ngx_null_command
+};
+
+
+/*
+ * Module context
+ */
+static ngx_http_module_t ngx_http_apache_rewrite_module_ctx = {
+    NULL,                                       /* preconfiguration */
+    ngx_http_apache_rewrite_postconfiguration,  /* postconfiguration */
+
+    NULL,                                       /* create main configuration */
+    NULL,                                       /* init main configuration */
+
+    ngx_http_apache_rewrite_create_srv_conf,    /* create server configuration */
+    ngx_http_apache_rewrite_merge_srv_conf,     /* merge server configuration */
+
+    ngx_http_apache_rewrite_create_loc_conf,    /* create location configuration */
+    ngx_http_apache_rewrite_merge_loc_conf      /* merge location configuration */
+};
+
+
+/*
+ * Module definition
+ */
+ngx_module_t ngx_http_apache_rewrite_module = {
+    NGX_MODULE_V1,
+    &ngx_http_apache_rewrite_module_ctx,        /* module context */
+    ngx_http_apache_rewrite_commands,            /* module directives */
+    NGX_HTTP_MODULE,                             /* module type */
+    NULL,                                        /* init master */
+    NULL,                                        /* init module */
+    NULL,                                        /* init process */
+    NULL,                                        /* init thread */
+    NULL,                                        /* exit thread */
+    NULL,                                        /* exit process */
+    NULL,                                        /* exit master */
+    NGX_MODULE_V1_PADDING
+};
+
+
+/* ============================================================
+ *   Configuration create/merge
+ * ============================================================ */
+
+static void *
+ngx_http_apache_rewrite_create_srv_conf(ngx_conf_t *cf)
+{
+    ngx_http_apache_rewrite_srv_conf_t *conf;
+
+    conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_apache_rewrite_srv_conf_t));
+    if (conf == NULL) {
+        return NULL;
+    }
+
+    conf->state = ENGINE_DISABLED;
+    conf->options = OPTION_NONE;
+
+    conf->rules = ngx_array_create(cf->pool, 4, sizeof(ngx_rewrite_rule_t));
+    conf->pending_conds = ngx_array_create(cf->pool, 4,
+                                           sizeof(ngx_rewrite_cond_t));
+    conf->maps = ngx_array_create(cf->pool, 2,
+                                  sizeof(ngx_rewrite_map_entry_t));
+
+    if (conf->rules == NULL || conf->pending_conds == NULL
+        || conf->maps == NULL)
+    {
+        return NULL;
+    }
+
+    conf->htaccess_enable = 0;
+    conf->htaccess_enable_set = 0;
+
+    conf->fallback_to_index = 1;
+
+    return conf;
+}
+
+
+static char *
+ngx_http_apache_rewrite_merge_srv_conf(ngx_conf_t *cf,
+    void *parent, void *child)
+{
+    ngx_http_apache_rewrite_srv_conf_t *prev = parent;
+    ngx_http_apache_rewrite_srv_conf_t *conf = child;
+
+    if (!conf->state_set) {
+        conf->state = prev->state;
+    }
+
+    if (!conf->options_set) {
+        conf->options = prev->options;
+    }
+
+    if (!conf->htaccess_enable_set) {
+        conf->htaccess_enable = prev->htaccess_enable;
+    }
+
+    if (!conf->fallback_to_index_set){
+        conf->fallback_to_index = prev->fallback_to_index;
+    }
+
+    /* Inherit rules if child has none and Inherit option is set */
+    if (conf->rules->nelts == 0
+        && prev->rules->nelts > 0
+        && (conf->options & OPTION_INHERIT))
+    {
+        ngx_uint_t         i;
+        ngx_rewrite_rule_t *src, *dst;
+
+        src = prev->rules->elts;
+        for (i = 0; i < prev->rules->nelts; i++) {
+            dst = ngx_array_push(conf->rules);
+            if (dst == NULL) {
+                return NGX_CONF_ERROR;
+            }
+            *dst = src[i];
+        }
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+static void *
+ngx_http_apache_rewrite_create_loc_conf(ngx_conf_t *cf)
+{
+    ngx_http_apache_rewrite_loc_conf_t *conf;
+
+    conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_apache_rewrite_loc_conf_t));
+    if (conf == NULL) {
+        return NULL;
+    }
+
+    conf->state = ENGINE_DISABLED;
+    conf->options = OPTION_NONE;
+
+    conf->rules = ngx_array_create(cf->pool, 4, sizeof(ngx_rewrite_rule_t));
+    conf->pending_conds = ngx_array_create(cf->pool, 4,
+                                           sizeof(ngx_rewrite_cond_t));
+
+    if (conf->rules == NULL || conf->pending_conds == NULL) {
+        return NULL;
+    }
+
+    ngx_str_null(&conf->baseurl);
+
+    return conf;
+}
+
+
+static char *
+ngx_http_apache_rewrite_merge_loc_conf(ngx_conf_t *cf,
+    void *parent, void *child)
+{
+    ngx_http_apache_rewrite_loc_conf_t *prev = parent;
+    ngx_http_apache_rewrite_loc_conf_t *conf = child;
+
+    if (!conf->state_set) {
+        conf->state = prev->state;
+    }
+
+    if (!conf->options_set) {
+        conf->options = prev->options;
+    }
+
+    if (!conf->baseurl_set && prev->baseurl_set) {
+        conf->baseurl = prev->baseurl;
+        conf->baseurl_set = 1;
+    }
+
+    /* Inherit rules if child has none and Inherit option is set */
+    if (conf->rules->nelts == 0
+        && prev->rules->nelts > 0
+        && (conf->options & OPTION_INHERIT))
+    {
+        ngx_uint_t         i;
+        ngx_rewrite_rule_t *src, *dst;
+
+        src = prev->rules->elts;
+        for (i = 0; i < prev->rules->nelts; i++) {
+            dst = ngx_array_push(conf->rules);
+            if (dst == NULL) {
+                return NGX_CONF_ERROR;
+            }
+            *dst = src[i];
+        }
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+/* ============================================================
+ *   Postconfiguration: register phase handlers + FastCGI hooks
+ * ============================================================ */
+
+/**
+ * Register environment variable hook for downstream modules (FastCGI).
+ * This is called in CONTENT_PHASE to automatically pass E vars to FastCGI.
+ */
+static ngx_int_t
+ngx_http_apache_rewrite_env_register_hook(ngx_http_request_t *r)
+{
+    ngx_rewrite_ctx_t  *ctx;
+    ngx_http_apache_rewrite_loc_conf_t *lcf;
+
+    lcf = ngx_http_get_module_loc_conf(r, ngx_http_apache_rewrite_module);
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+
+    if (ctx && ctx->env_vars && lcf && lcf->state == ENGINE_ENABLED) {
+        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "mod_rewrite: %d environment vars available for FastCGI",
+                       ctx->env_vars);
+        /* Automatically add all E-vars to FastCGI params without manual config */
+        ngx_http_apache_rewrite_fastcgi_register(r);
+
+        /* Convert E=VAR:VAL format to HTTP headers for PHP/FastCGI access */
+        ngx_rewrite_add_env_as_headers(r);
+
+    }
+
+    return NGX_DECLINED;
+}
+
+static ngx_int_t
+ngx_http_apache_rewrite_url_register_hook(ngx_http_request_t *r)
+{
+    ngx_rewrite_ctx_t  *ctx;
+    ngx_str_t          path, args;
+    ngx_http_apache_rewrite_srv_conf_t *sconf;
+    ngx_http_apache_rewrite_loc_conf_t *lcf;
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+    lcf = ngx_http_get_module_loc_conf(r, ngx_http_apache_rewrite_module);
+    sconf = ngx_http_get_module_srv_conf(r, ngx_http_apache_rewrite_module);
+
+    ngx_int_t is_enabled = 0;
+
+    if (lcf && lcf->state == ENGINE_ENABLED) {
+        is_enabled = 1;
+    } else if (sconf && sconf->state == ENGINE_ENABLED) {
+        is_enabled= 1;
+    }
+
+    if (!is_enabled) {
+        return NGX_DECLINED;
+    }
+
+    if (ctx == NULL || !ctx->uri_changed) {
+        if (sconf && sconf->fallback_to_index == 1) {
+            return ngx_http_apache_rewrite_url_register_hook_with_fallback(r);
+        } else {
+            return NGX_DECLINED;
+        }
+
+    }
+
+    if (ctx->redirect_code != 0) {
+        return NGX_DECLINED;
+    }
+
+    ngx_rewrite_set_skip_after_redirect(r);
+
+    /* Initialize path and args before calling ngx_http_split_args */
+    path.data = r->uri.data;
+    path.len = r->uri.len;
+    args = r->args;
+
+    if (!args.data) {
+        ngx_http_split_args(r, &path, &args);
+    }
+
+    (void)ngx_http_internal_redirect(r, &path, &args);
+
+    ngx_http_finalize_request(r, NGX_DONE);
+    return NGX_DONE;
+}
+
+
+static ngx_int_t
+ngx_http_apache_rewrite_postconfiguration(ngx_conf_t *cf)
+{
+    ngx_http_handler_pt       *h;
+    ngx_http_core_main_conf_t *cmcf;
+
+    cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
+
+    /* SERVER_REWRITE_PHASE handler (runs before location matching) */
+    h = ngx_array_push(&cmcf->phases[NGX_HTTP_SERVER_REWRITE_PHASE].handlers);
+    if (h == NULL) {
+        return NGX_ERROR;
+    }
+    *h = ngx_http_apache_rewrite_server_handler;
+
+    /* REWRITE_PHASE handler (runs inside matched location) */
+    h = ngx_array_push(&cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers);
+    if (h == NULL) {
+        return NGX_ERROR;
+    }
+    *h = ngx_http_apache_rewrite_location_handler;
+
+    /* CONTENT_PHASE handler - automatically pass E vars to FastCGI via HTTP headers */
+    h = ngx_array_push(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers);
+    if (h == NULL) {
+        return NGX_ERROR;
+    }
+    *h = ngx_http_apache_rewrite_env_register_hook;
+
+    h = ngx_array_push(&cmcf->phases[NGX_HTTP_PRECONTENT_PHASE].handlers);
+    if (h == NULL) {
+        return NGX_ERROR;
+    }
+
+    *h = ngx_http_apache_rewrite_url_register_hook;
+
+    return NGX_OK;
+}
+
+static ngx_int_t ngx_process_rules_result(ngx_int_t rc, ngx_rewrite_ctx_t *ctx,
+    ngx_http_request_t *r, int server){
+    if (rc == 0) {
+        return NGX_DECLINED;
+    }
+
+    if (rc == ACTION_STATUS || rc == ACTION_STATUS_SET) {
+        ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+        if (ctx && ctx->status_code > 0) {
+            return ctx->status_code;
+        }
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    }
+
+    /* Check for redirect */
+    ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+    if (ctx && ctx->redirect_url.len > 0) {
+        ngx_http_clear_location(r);
+        r->headers_out.location = ngx_list_push(&r->headers_out.headers);
+        if (r->headers_out.location == NULL) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+
+        r->headers_out.location->hash = 1;
+        ngx_str_set(&r->headers_out.location->key, "Location");
+        r->headers_out.location->value = ctx->redirect_url;
+
+        if (server){
+            ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                           "mod_rewrite: redirect to \"%V\" (%d)",
+                           &ctx->redirect_url, ctx->redirect_code);
+        }
+
+        return ctx->redirect_code;
+    }
+
+    if (rc == ACTION_NORMAL || rc == ACTION_NOESCAPE) {
+        if (server){
+            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                           "mod_rewrite: server rewrite to \"%V\"", &r->uri);
+        } else {
+            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                           "mod_rewrite: location rewrite to \"%V\"", &r->uri);
+        }
+
+        return NGX_DECLINED;
+    }
+
+    return NGX_DECLINED;
+}
+
+
+/* ============================================================
+ *   Phase handlers
+ * ============================================================ */
+
+/*
+ * Server-level rewrite handler (like Apache translate_name hook).
+ * Runs in NGX_HTTP_SERVER_REWRITE_PHASE.
+ */
+static ngx_int_t
+ngx_http_apache_rewrite_server_handler(ngx_http_request_t *r)
+{
+    ngx_http_apache_rewrite_srv_conf_t *sconf;
+    ngx_rewrite_ctx_t                  *ctx;
+    ngx_int_t                           rc;
+
+    sconf = ngx_http_get_module_srv_conf(r, ngx_http_apache_rewrite_module);
+
+    if (sconf == NULL || sconf->state != ENGINE_ENABLED) {
+        return NGX_DECLINED;
+    }
+
+    if (sconf->rules->nelts == 0) {
+        return NGX_DECLINED;
+    }
+
+    /* Check END flag */
+    ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+    if (ctx && ctx->end) {
+        return NGX_DECLINED;
+    }
+
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "mod_rewrite: server handler, uri=\"%V\"", &r->uri);
+
+    ngx_str_t baseurl = ngx_null_string;
+
+    rc = ngx_rewrite_apply_list(r, sconf->rules, NULL, baseurl, 0);
+
+    return ngx_process_rules_result(rc, ctx, r, 1);
+}
+
+
+/*
+ * Create htaccess entry and store in pool cleanup (duplicated for redirect preservation)
+ * Returns the created entry or NULL on error.
+ */
+static htaccess_entry_t *
+ngx_htaccess_create_in_pool_cleanup(ngx_http_request_t *r, ngx_str_t file_path, time_t mtime,
+    ngx_http_apache_rewrite_loc_conf_t *parsed_rules, ngx_htaccess_pool_cleanup_ctx_t *pool)
+{
+    /* Allocate pool cleanup context */
+    ngx_pool_cleanup_t     *cln;
+    ngx_htaccess_pool_cleanup_ctx_t *pool_cleanup_ctx;
+
+    if (!pool){
+        cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_htaccess_pool_cleanup_ctx_t));
+        if (cln == NULL) {
+            return NULL;
+        }
+
+        pool_cleanup_ctx = cln->data;
+        pool_cleanup_ctx->htaccess_cache_entries_head = NULL;
+        cln->handler = ngx_htaccess_cleanup;
+    } else {
+        pool_cleanup_ctx = pool;
+    }
+
+    /* Create new entry */
+    htaccess_entry_t *new_entry = ngx_pcalloc(r->pool, sizeof(htaccess_entry_t));
+    if (new_entry == NULL) {
+        return NULL;
+    }
+
+    /* Copy file_path as string */
+    new_entry->file_path = ngx_pcalloc(r->pool, file_path.len + 1);
+    if (new_entry->file_path == NULL) {
+        return NULL;
+    }
+    ngx_memcpy(new_entry->file_path, file_path.data, file_path.len);
+
+    /* Set fallback path - use RewriteFallBack from .htaccess or default /index.php */
+    if (!parsed_rules->fallback_path.data || parsed_rules->fallback_path.len == 0) {
+        ngx_str_set(&new_entry->fallback_path, "/index.php");
+    } else {
+        new_entry->fallback_path = parsed_rules->fallback_path;
+    }
+
+    new_entry->mtime = mtime;
+    new_entry->rules = parsed_rules->rules;
+    new_entry->baseurl = parsed_rules->baseurl;
+    new_entry->baseurl_set = parsed_rules->baseurl_set;
+    new_entry->options = parsed_rules->options;
+    new_entry->options_set = parsed_rules->options_set;
+    new_entry->state = parsed_rules->state;
+    new_entry->state_set = parsed_rules->state_set;
+
+    /* Link into pool cleanup list */
+    new_entry->next = pool_cleanup_ctx->htaccess_cache_entries_head;
+    pool_cleanup_ctx->htaccess_cache_entries_head = new_entry;
+
+    return new_entry;
+}
+
+
+/*
+ * Cleanup handler - called when request completes or redirect occurs
+ * (Currently used for documentation only - no actual cleanup needed)
+ */
+static void
+ngx_htaccess_cleanup(void *data)
+{
+    /* Pool cleanup context is automatically freed with pool */
+    ngx_htaccess_pool_cleanup_ctx_t *pool_cleanup_ctx = data;
+    (void)pool_cleanup_ctx;
+}
+
+
+/*
+ * Get cached htaccess entries from pool cleanup when ctx is NULL
+ * Searches through r->pool->cleanup for matching handler
+ */
+static ngx_htaccess_pool_cleanup_ctx_t *
+ngx_htaccess_get_from_pool_cleanup(ngx_http_request_t *r)
+{
+    ngx_pool_cleanup_t     *cln;
+
+    /* Search through all cleanup handlers in pool */
+    for (cln = r->pool->cleanup; cln != NULL; cln = cln->next) {
+        if (cln->handler == ngx_htaccess_cleanup) {
+            ngx_htaccess_pool_cleanup_ctx_t *pool_cleanup_ctx = cln->data;
+            return pool_cleanup_ctx;
+        }
+    }
+
+    /* No cached entries found */
+    return NULL;
+}
+
+
+/*
+ * Update or create htaccess cache entry in linked list
+ * Uses double storage mechanism: ctx (fast access) + pool cleanup (redirect preservation)
+ *
+ * Algorithm:
+ * 1. Try to get from ctx first
+ * 2. If ctx == NULL, search in pool cleanup
+ * 3. If found in cleanup - create ctx and copy entries
+ * 4. If not found anywhere - create new entry in both ctx and pool cleanup
+ */
+static void
+ngx_htaccess_update_cache(ngx_http_request_t *r, ngx_str_t file_path, time_t mtime, ngx_http_apache_rewrite_loc_conf_t *parsed_rules)
+{
+    ngx_rewrite_ctx_t  *ctx;
+    ngx_htaccess_pool_cleanup_ctx_t   *pool_entries;
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+    pool_entries = ngx_htaccess_get_from_pool_cleanup(r);
+
+
+    /* Step 1: Try to get from ctx first */
+    if (ctx != NULL && ctx->htaccess_cache_head != NULL) {
+        /* Search existing entry by path in ctx */
+        htaccess_entry_t *entry = ctx->htaccess_cache_head;
+        while (entry != NULL) {
+            if (ngx_strncmp((const char *)entry->file_path, (const char *)file_path.data, file_path.len) == 0) {
+                /* Found matching entry in ctx - update mtime and rules if newer */
+                if (mtime >= entry->mtime) {
+                    entry->mtime = mtime;
+                    entry->rules = parsed_rules->rules;
+                    if (!parsed_rules->fallback_path.data || parsed_rules->fallback_path.len == 0) {
+                        ngx_str_set(&entry->fallback_path, "/index.php");
+                    } else {
+                        entry->fallback_path = parsed_rules->fallback_path;
+                    }
+                }
+                return;
+            }
+            entry = entry->next;
+        }
+
+        /* Entry not found in ctx but ctx exists - need to create new */
+    } else if (ctx == NULL) {
+
+        if (pool_entries != NULL) {
+            /* Found entries in pool cleanup - copy them to ctx */
+            ctx = ngx_pcalloc(r->pool, sizeof(ngx_rewrite_ctx_t));
+            if (ctx == NULL) {
+                return;
+            }
+            ngx_http_set_ctx(r, ctx, ngx_http_apache_rewrite_module);
+
+            ctx->htaccess_cache_head = pool_entries->htaccess_cache_entries_head;
+
+            htaccess_entry_t *entry = NULL;
+            if (ctx && ctx->htaccess_cache_head) {
+                entry = ctx->htaccess_cache_head;
+                while (entry != NULL) {
+                    if (ngx_strncmp((const char *)entry->file_path, (const char *)file_path.data, file_path.len) == 0) {
+                        /* Found matching entry - update mtime and rules */
+                        if (mtime >= entry->mtime) {
+                            entry->mtime = mtime;
+                            entry->rules = parsed_rules->rules;
+                            if (!parsed_rules->fallback_path.data || parsed_rules->fallback_path.len == 0) {
+                                ngx_str_set(&entry->fallback_path, "/index.php");
+                            } else {
+                                entry->fallback_path = parsed_rules->fallback_path;
+                            }
+                        }
+                        return; /* Entry found and updated - no need to create new */
+                    }
+                    entry = entry->next;
+                }
+            }
+
+        }
+    }
+
+    htaccess_entry_t *new_entry = ngx_htaccess_create_in_pool_cleanup(r, file_path, mtime, parsed_rules, pool_entries);
+
+    if (new_entry == NULL) {
+        return;
+    }
+
+    /* Also add to ctx if it exists */
+    if (ctx && ctx->htaccess_cache_head) {
+        /* Not found in ctx - insert at head */
+        ctx->htaccess_cache_head = new_entry;
+    } else {
+        if (ctx == NULL) {
+            ctx = ngx_pcalloc(r->pool, sizeof(ngx_rewrite_ctx_t));
+            if (ctx == NULL) {
+                return;
+            }
+            ngx_http_set_ctx(r, ctx, ngx_http_apache_rewrite_module);
+        }
+        ctx->htaccess_cache_head = new_entry;
+
+    }
+}
+
+
+/*
+ * Search upward from current directory to DocRoot for .htaccess file
+ * Returns NGX_OK if found (found_path contains the full path)
+ * Returns NGX_ERROR if not found or error occurred.
+ */
+static ngx_int_t
+ngx_htaccess_search_upward(ngx_http_request_t *r, u_char *docroot, size_t docroot_len, ngx_str_t *current_path,
+    u_char *htaccess_name, size_t htaccess_name_len, ngx_str_t *found_path)
+{
+    /* Start from current path (document root + URI without filename) */
+    u_char *path_buf = (u_char *)ngx_palloc(r->pool, current_path->len + 1 + htaccess_name_len);
+    size_t  current_pos;
+
+    if (!path_buf) {
+        return NGX_ERROR;
+    }
+
+    /* Copy current path to buffer */
+    ngx_memcpy(path_buf, current_path->data, current_path->len);
+    ngx_memcpy(path_buf + current_path->len , htaccess_name, htaccess_name_len);
+
+    /* Set starting position */
+    current_pos = current_path->len - 1;
+    path_buf[current_path->len + htaccess_name_len] = '\0';
+
+
+
+    /* Iterate upward from current directory up to docroot */
+    while (1) {
+        /* Check if file exists at this level */
+        struct stat st;
+        if (stat((char *)path_buf, &st) == 0 && ngx_is_file(&st)) {
+            /* Found .htaccess! */
+            found_path->data = path_buf;
+            found_path->len = current_pos + 1 + htaccess_name_len;
+
+            return NGX_OK;
+        }
+
+        /* Go up one level: remove last directory component */
+        u_char *last_slash = NULL;
+        for (u_char *p = path_buf + current_pos - 2; p >= path_buf && docroot_len <= (size_t)(p - (u_char *)&path_buf); p--) {
+            if (*p == '/') {
+                last_slash = p;
+                break;
+            }
+        }
+
+        if (last_slash == NULL) {
+            /* Reached DocRoot without finding htaccess */
+            return NGX_ERROR;
+        }
+
+        /* Remove the directory component */
+        current_pos = last_slash - path_buf;
+
+        if (current_pos < docroot_len) {
+            /* Reached or passed DocRoot - no htaccess found */
+            return NGX_ERROR;
+        }
+
+        ngx_memcpy(path_buf + current_pos + 1, htaccess_name, htaccess_name_len);
+        path_buf[current_pos + 1 + htaccess_name_len] = '\0';
+    }
+}
+
+/*
+ * Build .htaccess path for current request.
+ * Searches upward from current directory up to DocRoot.
+ * Returns NGX_OK if found, NGX_ERROR if not found or error occurred.
+ */
+static ngx_int_t
+ngx_htaccess_build_path(ngx_http_request_t *r, u_char *docroot, size_t docroot_len,
+    ngx_str_t *path, u_char *htaccess_name, size_t htaccess_len)
+{
+    /* Build full path: docroot + r->uri */
+    size_t uri_len = r->uri.len;
+
+    /* Calculate exact size needed: docroot + '/' + uri + .htaccess */
+    /* Add extra for safety */
+    size_t alloc_size = docroot_len + 1 + uri_len + htaccess_len * 2;
+
+    path->data = (u_char *)ngx_palloc(r->pool, alloc_size);
+    if (path->data == NULL) {
+        return NGX_ERROR;
+    }
+
+    /* Copy docroot */
+    ngx_memcpy(path->data, docroot, docroot_len);
+    path->len = docroot_len;
+
+    if (path->len > 0 && path->data[path->len - 1] != '/') {
+        path->data[path->len++] = '/';
+    }
+
+    /* Add separator '/' between docroot and URI */
+    if (uri_len > 0) {
+        if (r->uri.data[0] != '/') {
+            ngx_memcpy(path->data + path->len, r->uri.data, uri_len);
+            path->len += uri_len;
+        } else {
+            ngx_memcpy(path->data + path->len, r->uri.data + 1, uri_len - 1);
+            path->len += (uri_len - 1);
+        }
+
+        /* Find last '/' in path and extract directory component */
+        u_char *last_slash = NULL;
+        for (u_char *p = path->data + path->len - 1; p >= path->data; p--) {
+            if (*p == '/') {
+                last_slash = p;
+                break;
+            }
+        }
+
+        if (last_slash) {
+            /* Found directory in URI - truncate to include only directory */
+            /* Keep everything up to and including the last '/' */
+            path->len = last_slash - path->data + 1;
+
+        } else {
+            //Nothing do
+        }
+
+    } else {
+        ngx_memcpy(path->data + path->len, htaccess_name, htaccess_len);
+        path->len += htaccess_len;
+    }
+
+    return NGX_OK;
+}
+
+
+static ngx_array_t *
+ngx_htaccess_parse_line(ngx_pool_t *pool, const char *line)
+{
+    /* Allocate a mutable copy of the input line */
+    size_t  len   = strlen(line);
+    u_char *buf   = ngx_palloc(pool, len + 1);
+    u_char *b_word = NULL;
+    if (buf == NULL) {
+        return NULL;
+    }
+    ngx_memcpy(buf, line, len + 1);
+
+    /* Trim leading whitespace */
+    u_char *start = buf;
+    while (*start && isspace(*start)) {
+        start++;
+    }
+
+    /* Trim trailing whitespace */
+    u_char *end = buf + strlen((char *)start);
+    while (end > start && isspace(end[-1])) {
+        end--;
+    }
+    size_t trimmed_len = end - start;
+    if (trimmed_len == 0) {
+        return NULL;   /* empty line after trimming */
+    }
+
+    /* If the first non‑whitespace character is '#', ignore the line */
+    if (*start == '#') {
+        return NULL;
+    }
+
+    /* Create an array for the words */
+    ngx_array_t *words = ngx_array_create(pool, 4, sizeof(ngx_str_t));
+    if (words == NULL) {
+        return NULL;
+    }
+
+    /* Split on whitespace, collapsing multiple spaces */
+    u_char *p = start;
+    while (p < end) {
+        /* Skip any leading spaces between words */
+        while (p < end && isspace(*p)) {
+            p++;
+        }
+        if (p >= end) {
+            break;
+        }
+
+        u_char *w_start = p;
+        while (p < end && !isspace(*p)) {
+            p++;
+        }
+        size_t w_len = p - w_start;
+
+        /* Handle double-quoted strings: strip surrounding quotes */
+        if (w_len >= 2 && w_start[0] == '"' && w_start[w_len - 1] == '"') {
+            w_start += 1;
+            w_len -= 2;
+        }
+
+        ngx_str_t *word = ngx_array_push(words);
+        if (word == NULL) {
+            return NULL;
+        }
+
+        b_word   = ngx_palloc(pool, w_len + 1);
+        if (!b_word) {
+            return NULL;
+        }
+
+        ngx_memzero(b_word, w_len + 1);
+        ngx_memcpy(b_word, w_start, w_len);
+
+        word->data = b_word;
+        word->len  = w_len;
+    }
+
+    return words;
+}
+
+static void * ngx_http_rewrite_rule_helper(int parsing, ngx_http_apache_rewrite_srv_conf_t *sconf,
+    ngx_http_apache_rewrite_loc_conf_t *lcf, ngx_conf_t *cf, ngx_array_t *args, ngx_http_request_t *r){
+    ngx_str_t                          *value;
+    ngx_rewrite_rule_t                 *rule;
+    ngx_regex_compile_t                 rc;
+    u_char                              errstr[NGX_MAX_CONF_ERRSTR];
+    ngx_array_t                        *rules, *pending_conds;
+    ngx_uint_t                          i;
+    ngx_rewrite_cond_t                 *pending, *cond_dst;
+    ngx_http_apache_rewrite_loc_conf_t *conf;
+    ngx_pool_t *pool;
+    ngx_uint_t nelts = 0;
+
+    if (!parsing) {
+        value = cf->args->elts;
+        nelts = cf->args->nelts;
+
+        /* Determine if we're in server or location context */
+        if (cf->cmd_type & NGX_HTTP_LOC_CONF) {
+            rules = lcf->rules;
+            pending_conds = lcf->pending_conds;
+        } else {
+            rules = sconf->rules;
+            pending_conds = sconf->pending_conds;
+        }
+        pool = cf->pool;
+    } else {
+        conf = lcf;
+        value = args->elts;
+        nelts = args->nelts;
+
+        rules = conf->rules;
+        pending_conds = conf->pending_conds;
+        pool = r->pool;
+    }
+
+    /* Create new rule */
+    rule = ngx_array_push(rules);
+    if (rule == NULL) {
+        return NGX_CONF_ERROR;
+    }
+    ngx_memzero(rule, sizeof(ngx_rewrite_rule_t));
+
+    rule->maxrounds = NGX_REWRITE_MAX_ROUNDS;
+    rule->forced_responsecode = 0;
+
+    /* arg1: pattern */
+    rule->pattern = value[1];
+
+    /* Check for negation prefix '!' */
+    if (rule->pattern.len > 0 && rule->pattern.data[0] == '!') {
+        rule->flags |= RULEFLAG_NOTMATCH;
+        rule->pattern.data++;
+        rule->pattern.len--;
+    }
+
+    /* arg3: optional flags */
+    if (nelts >= 4) {
+        ngx_str_t flags_str = value[3];
+        ngx_rewrite_strip_brackets(&flags_str);
+        if (ngx_http_rewrite_parse_rule_flags(pool, &flags_str, rule)
+            != NGX_OK)
+        {
+            return NGX_CONF_ERROR;
+        }
+    }
+
+    /* Compile regex (after flags parsed, to know NC) */
+    if (value[2].len == 1 && value[2].data[0] == '-') {
+        /* Substitution '-' = no substitution */
+        rule->flags |= RULEFLAG_NOSUB;
+        ngx_str_null(&rule->output);
+        /* Still need to compile the pattern for matching */
+    } else {
+        rule->output = value[2];
+    }
+
+    ngx_memzero(&rc, sizeof(ngx_regex_compile_t));
+    rc.pattern = rule->pattern;
+    rc.pool = pool;
+    rc.err.len = NGX_MAX_CONF_ERRSTR;
+    rc.err.data = errstr;
+
+    if (rule->flags & RULEFLAG_NOCASE) {
+        rc.options = NGX_REGEX_CASELESS;
+    }
+
+    if (ngx_regex_compile(&rc) != NGX_OK) {
+        if (!parsing) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                "RewriteRule: invalid regex \"%V\": %V",
+                &rule->pattern, &rc.err);
+        } else {
+            ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                "RewriteRule: invalid regex \"%V\": %V",
+                &rule->pattern, &rc.err);
+        }
+        return NGX_CONF_ERROR;
+    }
+
+    rule->regex = rc.regex;
+
+    /* Attach pending conditions */
+    rule->conditions = ngx_array_create(pool, pending_conds->nelts + 1,
+                                        sizeof(ngx_rewrite_cond_t));
+    if (rule->conditions == NULL) {
+        return NGX_CONF_ERROR;
+    }
+
+    if (pending_conds->nelts > 0) {
+        pending = pending_conds->elts;
+        for (i = 0; i < pending_conds->nelts; i++) {
+            cond_dst = ngx_array_push(rule->conditions);
+            if (cond_dst == NULL) {
+                return NGX_CONF_ERROR;
+            }
+            *cond_dst = pending[i];
+        }
+        pending_conds->nelts = 0; /* clear pending */
+    }
+
+    return NULL;
+
+}
+
+void * ngx_http_rewrite_cond_helper(int parsing, ngx_http_apache_rewrite_srv_conf_t *sconf,
+    ngx_http_apache_rewrite_loc_conf_t *lcf, ngx_conf_t *cf, ngx_array_t *args, ngx_http_request_t *r){
+        ngx_str_t                          *value;
+        ngx_rewrite_cond_t                 *cond;
+        ngx_array_t                        *pending_conds;
+        ngx_regex_compile_t                 rc;
+        u_char                              errstr[NGX_MAX_CONF_ERRSTR];
+        u_char                             *pat;
+        size_t                              pat_len;
+        ngx_pool_t *pool;
+        ngx_uint_t nelts = 0;
+        ngx_http_apache_rewrite_loc_conf_t *conf;
+
+        if (!parsing){
+            pool = cf->pool;
+            nelts = cf->args->nelts;
+            value = cf->args->elts;
+
+            sconf = ngx_http_conf_get_module_srv_conf(cf,
+                        ngx_http_apache_rewrite_module);
+            lcf = ngx_http_conf_get_module_loc_conf(cf,
+                        ngx_http_apache_rewrite_module);
+
+            /* Determine context */
+            if (cf->cmd_type & NGX_HTTP_LOC_CONF) {
+                pending_conds = lcf->pending_conds;
+            } else {
+                pending_conds = sconf->pending_conds;
+            }
+        } else {
+            conf = lcf;
+            value = args->elts;
+            nelts = args->nelts;
+
+            pending_conds = conf->pending_conds;
+            pool = r->pool;
+        }
+
+        /* Create new condition in pending list */
+        cond = ngx_array_push(pending_conds);
+        if (cond == NULL) {
+            return NGX_CONF_ERROR;
+        }
+        ngx_memzero(cond, sizeof(ngx_rewrite_cond_t));
+
+        /* arg1: test string */
+        cond->input = value[1];
+
+        /* arg3: optional flags (parse before pattern for NC) */
+        cond->flags = CONDFLAG_NONE;
+        if (nelts >= 4) {
+            ngx_str_t flags_str = value[3];
+            ngx_rewrite_strip_brackets(&flags_str);
+            if (ngx_http_rewrite_parse_cond_flags(cf, &flags_str, cond)
+                != NGX_OK)
+            {
+                return NGX_CONF_ERROR;
+            }
+        }
+
+        /* arg2: condition pattern */
+        pat = value[2].data;
+        pat_len = value[2].len;
+
+        /* Check for negation */
+        if (pat_len > 0 && pat[0] == '!') {
+            cond->flags |= CONDFLAG_NOTMATCH;
+            pat++;
+            pat_len--;
+        }
+
+        /* Determine pattern type */
+        cond->ptype = CONDPAT_REGEX;
+
+        if (pat_len >= 2 && pat[0] == '-') {
+            /* File/directory test patterns */
+            if (pat_len == 2) {
+                switch (pat[1]) {
+                case 'f': cond->ptype = CONDPAT_FILE_EXISTS; break;
+                case 's': cond->ptype = CONDPAT_FILE_SIZE;   break;
+                case 'd': cond->ptype = CONDPAT_FILE_DIR;    break;
+                case 'x': cond->ptype = CONDPAT_FILE_XBIT;   break;
+                case 'h': case 'l': case 'L':
+                    cond->ptype = CONDPAT_FILE_LINK;
+                    break;
+                }
+            }
+            /* Integer comparison: -lt, -le, -eq, -gt, -ge, -ne */
+            else if (pat_len >= 3 && pat[1] != '-') {
+                if (pat[1] == 'l' && pat[2] == 't') {
+                    cond->ptype = CONDPAT_INT_LT;
+                    pat += 3; pat_len -= 3;
+                } else if (pat[1] == 'l' && pat[2] == 'e') {
+                    cond->ptype = CONDPAT_INT_LE;
+                    pat += 3; pat_len -= 3;
+                } else if (pat[1] == 'e' && pat[2] == 'q') {
+                    cond->ptype = CONDPAT_INT_EQ;
+                    pat += 3; pat_len -= 3;
+                } else if (pat[1] == 'g' && pat[2] == 't') {
+                    cond->ptype = CONDPAT_INT_GT;
+                    pat += 3; pat_len -= 3;
+                } else if (pat[1] == 'g' && pat[2] == 'e') {
+                    cond->ptype = CONDPAT_INT_GE;
+                    pat += 3; pat_len -= 3;
+                } else if (pat[1] == 'n' && pat[2] == 'e') {
+                    /* -ne is !-eq */
+                    cond->ptype = CONDPAT_INT_EQ;
+                    cond->flags ^= CONDFLAG_NOTMATCH;
+                    pat += 3; pat_len -= 3;
+                }
+            }
+        }
+        /* String comparison operators */
+        else if (pat_len >= 1) {
+            if (pat[0] == '>') {
+                if (pat_len >= 2 && pat[1] == '=') {
+                    cond->ptype = CONDPAT_STR_GE;
+                    pat += 2; pat_len -= 2;
+                } else {
+                    cond->ptype = CONDPAT_STR_GT;
+                    pat += 1; pat_len -= 1;
+                }
+            } else if (pat[0] == '<') {
+                if (pat_len >= 2 && pat[1] == '=') {
+                    cond->ptype = CONDPAT_STR_LE;
+                    pat += 2; pat_len -= 2;
+                } else {
+                    cond->ptype = CONDPAT_STR_LT;
+                    pat += 1; pat_len -= 1;
+                }
+            } else if (pat[0] == '=') {
+                cond->ptype = CONDPAT_STR_EQ;
+                pat += 1; pat_len -= 1;
+                /* Handle ="" for empty string */
+                if (pat_len == 2 && pat[0] == '"' && pat[1] == '"') {
+                    pat_len = 0;
+                }
+            }
+        }
+
+        /* Store the (possibly adjusted) pattern */
+        cond->pattern.data = pat;
+        cond->pattern.len = pat_len;
+
+        /* Compile regex if needed */
+        if (cond->ptype == CONDPAT_REGEX) {
+            ngx_memzero(&rc, sizeof(ngx_regex_compile_t));
+            rc.pattern.data = pat;
+            rc.pattern.len = pat_len;
+            rc.pool = pool;
+            rc.err.len = NGX_MAX_CONF_ERRSTR;
+            rc.err.data = errstr;
+
+            if (cond->flags & CONDFLAG_NOCASE) {
+                rc.options = NGX_REGEX_CASELESS;
+            }
+
+            if (ngx_regex_compile(&rc) != NGX_OK) {
+                if (!parsing){
+                    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                        "RewriteCond: invalid regex \"%*s\": %V",
+                        pat_len, pat, &rc.err);
+                } else {
+                    ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                        "RewriteCond: invalid regex \"%*s\": %V",
+                        pat_len, pat, &rc.err);
+                }
+                return NGX_CONF_ERROR;
+            }
+
+            cond->regex = rc.regex;
+        }
+
+        return NULL;
+}
+
+/*
+ * Parse .htaccess file and extract rewrite rules.
+ * Returns NGX_OK on success, NGX_ERROR on error.
+ */
+static ngx_http_apache_rewrite_loc_conf_t *
+ngx_htaccess_parse_file_from_ha(ngx_http_request_t *r, ngx_str_t *file_path)
+{
+    FILE   *fp;
+    char  line_buf_raw[4096];
+    char  line_buf[4096];
+    size_t  line_len;
+
+    ngx_http_apache_rewrite_loc_conf_t *conf;
+    ngx_pool_t *pool = r->pool;
+
+    conf = ngx_pcalloc(pool, sizeof(ngx_http_apache_rewrite_loc_conf_t));
+    if (conf == NULL) {
+        return NULL;
+    }
+
+    conf->state = ENGINE_DISABLED;
+    conf->options = OPTION_NONE;
+
+    conf->rules = ngx_array_create(pool, 4, sizeof(ngx_rewrite_rule_t));
+    conf->pending_conds = ngx_array_create(pool, 4,
+                                           sizeof(ngx_rewrite_cond_t));
+
+    if (conf->rules == NULL || conf->pending_conds == NULL) {
+        return NULL;
+    }
+
+    ngx_str_null(&conf->baseurl);
+    ngx_str_null(&conf->fallback_path);
+
+    fp = fopen((const char *)file_path->data, "r");
+    if (fp == NULL) {
+        return NULL;
+    }
+    /* Initialize state to enabled */
+    while (fgets(line_buf_raw, sizeof(line_buf_raw), fp) != NULL) {
+        line_len = strlen(line_buf_raw);
+
+        char *p_line_buf_raw = line_buf_raw;
+        /* Skip leading spaces and tabs */
+        while (*p_line_buf_raw && (*p_line_buf_raw == ' ' || *p_line_buf_raw == '\t')) {
+            p_line_buf_raw++;
+        }
+        /* Skip trailing spaces and tabs */
+        char *q_line_buf_raw = p_line_buf_raw + strlen(p_line_buf_raw) - 1;
+        while (q_line_buf_raw >= p_line_buf_raw && (*q_line_buf_raw == ' ' || *q_line_buf_raw == '\t' || *q_line_buf_raw == '\n')) {
+            *q_line_buf_raw = '\0';
+            q_line_buf_raw--;
+        }
+        size_t trimmed_len = strlen(p_line_buf_raw);
+        ngx_memcpy(line_buf, p_line_buf_raw, trimmed_len + 1); /* include null terminator */
+        line_len = trimmed_len;
+
+        /* Skip empty lines and comments */
+        if (line_len == 0 || line_buf[0] == '#' || line_buf[0] == '\n') {
+            continue;
+        }
+        /* Trim trailing newline */
+        if (line_len > 0 && line_buf[line_len - 1] == '\n') {
+            line_buf[line_len - 1] = '\0';
+            line_len--;
+        }
+        /* -----------------------------------------------------------------
+         *  RewriteEngine
+         * ----------------------------------------------------------------- */
+        if (ngx_strncmp((u_char *)line_buf, "RewriteEngine", 13) == 0) {
+            u_char *p = (u_char *)(line_buf + 13);
+            while (*p && *p == ' ') p++;
+            if (ngx_strncasecmp(p, (u_char *)"on", 2) == 0) {
+                conf->state = ENGINE_ENABLED;
+            } else if (ngx_strncasecmp(p, (u_char *)"off", 3) == 0) {
+                conf->state = ENGINE_DISABLED;
+            }
+        /* -----------------------------------------------------------------
+         *  RewriteRule
+         * ----------------------------------------------------------------- */
+        } else if (ngx_strncmp(line_buf, "RewriteRule", 11) == 0) {
+            ngx_array_t *args = ngx_htaccess_parse_line(pool, (const char *)line_buf);
+
+            if (args) {
+
+                void *result = ngx_http_rewrite_rule_helper(1, NULL,
+                    conf, NULL, args, r);
+
+                if (result == NGX_CONF_ERROR) {
+                    fclose(fp);
+                    return NULL;
+                }
+
+            }
+
+        /* -----------------------------------------------------------------
+         *  RewriteBase – ignored in .htaccess
+         * ----------------------------------------------------------------- */
+        } else if (ngx_strncmp(line_buf, "RewriteBase", 11) == 0) {
+
+            ngx_array_t *args = ngx_htaccess_parse_line(pool, (const char *)line_buf);
+
+            if (args) {
+                ngx_http_apache_rewrite_loc_conf_t *lcf = conf;
+                ngx_str_t                          *value;
+
+                value = args->elts;
+
+                if (value[1].len == 0 || value[1].data[0] != '/') {
+                    return NULL;
+                }
+
+                lcf->baseurl = value[1];
+                lcf->baseurl_set = 1;
+            }
+
+        /* -----------------------------------------------------------------
+         *  RewriteCond
+         * ----------------------------------------------------------------- */
+        } else if (ngx_strncmp(line_buf, "RewriteCond", 11) == 0) {
+
+            ngx_array_t *args = ngx_htaccess_parse_line(pool, (const char *)line_buf);
+
+            if (args) {
+
+                void *result = ngx_http_rewrite_cond_helper(1, NULL,
+                    conf, NULL, args, r);
+
+                if (result == NGX_CONF_ERROR) {
+                    fclose(fp);
+                    return NULL;
+                }
+
+            }
+
+
+        /* -----------------------------------------------------------------
+         *  RewriteOptions – ignored in .htaccess
+         * ----------------------------------------------------------------- */
+        } else if (ngx_strncmp(line_buf, "RewriteOptions", 14) == 0) {
+
+            ngx_array_t *args = ngx_htaccess_parse_line(pool, (const char *)line_buf);
+
+            if (args) {
+                ngx_str_t                          *value;
+                ngx_uint_t                          i;
+
+                value = args->elts;
+
+                for (i = 1; i < args->nelts; i++) {
+                    if (ngx_strcasecmp(value[i].data, (u_char *) "Inherit") == 0) {
+                        conf->options |= OPTION_INHERIT;
+                        conf->options_set = 1;
+                    } else if (ngx_strcasecmp(value[i].data,
+                               (u_char *) "InheritBefore") == 0)
+                    {
+                        conf->options |= OPTION_INHERIT | OPTION_INHERIT_BEFORE;
+                        conf->options_set = 1;
+
+                    }
+                }
+            }
+
+        /* -----------------------------------------------------------------
+         *  RewriteFallBack – alternative fallback path (override default /index.php)
+         * ----------------------------------------------------------------- */
+        } else if (ngx_strncmp(line_buf, "RewriteFallBack", 15) == 0) {
+
+            ngx_array_t *args = ngx_htaccess_parse_line(pool, (const char *)line_buf);
+
+            if (args && args->nelts >= 2) {
+                ngx_str_t                          *value;
+
+                value = args->elts;
+
+                /* Validate fallback path starts with '/' */
+                if (value[1].len > 0 && value[1].data[0] != '/') {
+                    return NULL;
+                }
+
+                conf->fallback_path = value[1];
+            }
+
+        }
+    }
+    fclose(fp);
+    return conf;
+}
+
+
+/*
+ * Location-level rewrite handler (like Apache fixups hook).
+ * Runs in NGX_HTTP_REWRITE_PHASE.
+ */
+static ngx_int_t
+ngx_http_apache_rewrite_location_handler(ngx_http_request_t *r)
+{
+    ngx_http_apache_rewrite_loc_conf_t *lcf;
+    ngx_http_apache_rewrite_srv_conf_t *sconf;
+    ngx_http_core_loc_conf_t           *clcf;
+    ngx_rewrite_ctx_t                  *ctx;
+    ngx_str_t                           htaccess_path = ngx_null_string;
+    ngx_int_t                           rc;
+    ngx_http_apache_rewrite_loc_conf_t  *parsed_rules;
+    ngx_array_t                         *combined_rules;
+    ngx_str_t baseurl_htacess = ngx_null_string;
+    ngx_int_t options_htaccess = -1;
+    ngx_int_t state_htaccess = -1;
+
+    (void)options_htaccess;
+
+    lcf = ngx_http_get_module_loc_conf(r, ngx_http_apache_rewrite_module);
+    sconf = ngx_http_get_module_srv_conf(r, ngx_http_apache_rewrite_module);
+    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+
+    if (lcf == NULL || lcf->state != ENGINE_ENABLED) {
+        return NGX_DECLINED;
+    }
+
+    /* Check htaccess parsing enable */
+    if (!sconf->htaccess_enable_set || sconf->htaccess_enable != 1) {
+        /* Use only location rules */
+        if (lcf->rules->nelts == 0) {
+            return NGX_DECLINED;
+        }
+
+        ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+        if (ctx == NULL) {
+            ctx = ngx_pcalloc(r->pool, sizeof(ngx_rewrite_ctx_t));
+            if (ctx == NULL) {
+                return NGX_ERROR;
+            }
+            ngx_http_set_ctx(r, ctx, ngx_http_apache_rewrite_module);
+        }
+
+        if (ctx && ctx->end) {
+            return NGX_DECLINED;
+        }
+
+        /* Set default fallback path from config */
+        if (!ctx || !ctx->fallback_path.data) {
+            ngx_str_set(&ctx->fallback_path, "/index.php");
+        }
+
+        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "mod_rewrite: location handler (no htaccess), uri=\"%V\"", &r->uri);
+
+        rc = ngx_rewrite_apply_list(r, lcf->rules, NULL, lcf->baseurl, lcf->baseurl_set);
+
+        return ngx_process_rules_result(rc, ctx, r, 0);
+    }
+
+    /* Search upward from current directory up to DocRoot for .htaccess */
+    u_char *htaccess_name = sconf->htaccess_name.data ? (u_char *)sconf->htaccess_name.data : (u_char *)".htaccess";
+    size_t htaccess_name_len = sconf->htaccess_name.data ? sconf->htaccess_name.len : 9;
+
+    /* Build initial path: docroot + r->uri */
+    ngx_str_t current_path;
+    rc = ngx_htaccess_build_path(r, clcf->root.data, clcf->root.len, &current_path, htaccess_name, htaccess_name_len);
+
+    ngx_str_t htaccess_docroot = ngx_null_string;
+
+    /* Remove last component (filename) to search from parent directory */
+    if (rc == NGX_OK && current_path.len > 0) {
+
+        /* Search upward for .htaccess file */
+        rc = ngx_htaccess_search_upward(r, clcf->root.data, clcf->root.len, &current_path,
+                                        htaccess_name, htaccess_name_len, &htaccess_path);
+
+        if (rc == NGX_ERROR) {
+                /* File not found — use only location rules */
+                ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+                if (ctx && ctx->end) {
+                    return NGX_DECLINED;
+                }
+
+                rc = ngx_rewrite_apply_list(r, lcf->rules, NULL, lcf->baseurl, lcf->baseurl_set);
+
+                return ngx_process_rules_result(rc, ctx, r, 0);
+        }
+
+        htaccess_docroot.data = ngx_pcalloc(r->pool, htaccess_path.len);
+        size_t htaccess_docroot_vlen = htaccess_path.len - (clcf->root.len + 1) - htaccess_name_len;
+        if ((long)htaccess_docroot_vlen < 0) htaccess_docroot_vlen = 0;
+        ngx_memcpy(htaccess_docroot.data, htaccess_path.data + clcf->root.len + 1, htaccess_docroot_vlen);
+
+        htaccess_docroot.len = htaccess_path.len - (clcf->root.len + 1) - htaccess_name_len;
+    }
+
+    /* Check if htaccess file exists */
+    struct stat st;
+    if (!htaccess_path.data || stat((char *)htaccess_path.data, &st) == -1) {
+        /* File does not exist — use only location rules */
+        if (lcf->rules->nelts == 0) {
+            return NGX_DECLINED;
+        }
+
+        ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+        if (ctx == NULL) {
+            ctx = ngx_pcalloc(r->pool, sizeof(ngx_rewrite_ctx_t));
+            if (ctx == NULL) {
+                return NGX_ERROR;
+            }
+            ngx_http_set_ctx(r, ctx, ngx_http_apache_rewrite_module);
+        }
+
+        if (ctx && ctx->end) {
+            return NGX_DECLINED;
+        }
+
+        /* Set default fallback path */
+        if (!ctx || !ctx->fallback_path.data) {
+            ngx_str_set(&ctx->fallback_path, "/index.php");
+        }
+
+        rc = ngx_rewrite_apply_list(r, lcf->rules, NULL, lcf->baseurl, lcf->baseurl_set);
+
+        return ngx_process_rules_result(rc, ctx, r, 0);
+    }
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+
+    /* Step 1: Try to get cached entries from ctx first */
+    if (ctx == NULL) {
+        /* Step 2: No ctx, search in pool cleanup for preserved htaccess cache */
+        ctx = ngx_pcalloc(r->pool, sizeof(ngx_rewrite_ctx_t));
+        if (ctx != NULL) {
+            /* Copy all cached entries from pool cleanup into ctx */
+            ngx_htaccess_pool_cleanup_ctx_t *pool_entries = ngx_htaccess_get_from_pool_cleanup(r);
+            if (pool_entries != NULL) {
+                ctx->htaccess_cache_head = pool_entries->htaccess_cache_entries_head;
+
+                /* Set ctx for request */
+                ngx_http_set_ctx(r, ctx, ngx_http_apache_rewrite_module);
+            }
+        }
+    }
+
+    /* Search by linked list — find entry matching file_path */
+    combined_rules = NULL;
+    ngx_str_t fallback_from_cache = ngx_null_string;
+    if (ctx && ctx->htaccess_cache_head) {
+        htaccess_entry_t *entry = ctx->htaccess_cache_head;
+        while (entry != NULL) {
+            if (ngx_strncmp((const char *)entry->file_path, (const char *)htaccess_path.data, htaccess_path.len) == 0 &&
+                entry->mtime <= st.st_mtime) {
+                /* Found matching cached entry — use it */
+                combined_rules = entry->rules;
+                fallback_from_cache = entry->fallback_path;
+                if (entry->state_set)
+                    state_htaccess = entry->state;
+                if (entry->options_set)
+                    options_htaccess = entry->options;
+                if (entry->baseurl_set)
+                    baseurl_htacess = entry->baseurl;
+                break;
+            }
+            entry = entry->next;
+        }
+    }
+
+    /* If no cached rules, parse .htaccess file */
+    if (combined_rules == NULL) {
+
+        parsed_rules = ngx_htaccess_parse_file_from_ha(r, &htaccess_path);
+
+        if (!parsed_rules){
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+
+        combined_rules = parsed_rules->rules;
+        fallback_from_cache = !parsed_rules->fallback_path.data || parsed_rules->fallback_path.len == 0 ?
+                              (ngx_str_t)ngx_null_string : parsed_rules->fallback_path;
+        if (parsed_rules->state_set)
+            state_htaccess = parsed_rules->state;
+        if (parsed_rules->options_set)
+            options_htaccess = parsed_rules->options;
+        if (parsed_rules->baseurl_set)
+            baseurl_htacess = parsed_rules->baseurl;
+
+        /* Store in cache — add/update entry in linked list */
+        ngx_htaccess_update_cache(r, htaccess_path, st.st_mtime, parsed_rules);
+
+    }
+
+    if (state_htaccess == ENGINE_DISABLED)
+        return NGX_DECLINED;
+
+    /* Ensure ctx exists */
+    if (ctx == NULL) {
+        ctx = ngx_pcalloc(r->pool, sizeof(ngx_rewrite_ctx_t));
+        if (ctx == NULL) {
+            return NGX_ERROR;
+        }
+        ngx_http_set_ctx(r, ctx, ngx_http_apache_rewrite_module);
+    }
+
+    /* Set fallback path from htaccess cache or use default */
+    if (!ctx->fallback_path.data) {
+        if (fallback_from_cache.len > 0) {
+            ctx->fallback_path = fallback_from_cache;
+        } else {
+            ngx_str_set(&ctx->fallback_path, "/index.php");
+        }
+    }
+
+    /* Combine location rules with .htaccess rules (.htaccess has priority - added first) */
+    ngx_int_t final_rc;
+
+    if (combined_rules->nelts > 0 && lcf->rules->nelts > 0) {
+        /* Create combined array: htaccess rules first, then location rules */
+        ngx_array_t *final_rules = ngx_array_create(r->pool,
+            combined_rules->nelts + lcf->rules->nelts, sizeof(ngx_rewrite_rule_t));
+
+        if (final_rules == NULL) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+
+        /* Copy htaccess rules first */
+        for (ngx_uint_t j = 0; j < combined_rules->nelts; j++) {
+            ngx_rewrite_rule_t *src, *dst;
+            src = (ngx_rewrite_rule_t *)combined_rules->elts + j;
+            dst = ngx_array_push(final_rules);
+            if (dst == NULL) {
+                return NGX_HTTP_INTERNAL_SERVER_ERROR;
+            }
+            *dst = *src;
+        }
+
+        /* Copy location rules after */
+        for (ngx_uint_t j = 0; j < lcf->rules->nelts; j++) {
+            ngx_rewrite_rule_t *src, *dst;
+            src = (ngx_rewrite_rule_t *)lcf->rules->elts + j;
+            dst = ngx_array_push(final_rules);
+            if (dst == NULL) {
+                return NGX_HTTP_INTERNAL_SERVER_ERROR;
+            }
+            *dst = *src;
+        }
+
+        ngx_str_t local_base_url = ngx_null_string;
+        if (baseurl_htacess.len>0)
+            local_base_url = baseurl_htacess;
+        else if (lcf->baseurl_set)
+            local_base_url = lcf->baseurl;
+
+        final_rc = ngx_rewrite_apply_list(r, final_rules, &htaccess_docroot, local_base_url, local_base_url.len>0?1:0);
+
+    } else if (combined_rules->nelts > 0) {
+        /* Only htaccess rules */
+        final_rc = ngx_rewrite_apply_list(r, combined_rules, &htaccess_docroot, baseurl_htacess, baseurl_htacess.len>0?1:0);
+
+    } else {
+        /* Only location rules */
+        final_rc = ngx_rewrite_apply_list(r, lcf->rules, NULL, lcf->baseurl, lcf->baseurl_set);
+    }
+
+    return ngx_process_rules_result(final_rc, ctx, r, 0);
+}
+
+
+/* ============================================================
+ *   Flag parsing
+ * ============================================================ */
+
+/*
+ * Parse RewriteRule flags: "[R=301,L,NC,QSA]"
+ * Expects the content between [ and ] (without brackets).
+ */
+static ngx_int_t
+ngx_http_rewrite_parse_rule_flags(ngx_pool_t *pool,
+    ngx_str_t *flags_str, ngx_rewrite_rule_t *rule)
+{
+    u_char  *p, *start, *end, *eq;
+    u_char   flag_buf[256];
+    u_char   val_buf[256];
+    size_t   flag_len, val_len;
+
+    if (flags_str->len == 0) {
+        return NGX_OK;
+    }
+
+    p = flags_str->data;
+    end = p + flags_str->len;
+
+    while (p < end) {
+        /* skip whitespace and commas */
+        while (p < end && (*p == ',' || *p == ' ' || *p == '\t')) {
+            p++;
+        }
+        if (p >= end) {
+            break;
+        }
+
+        start = p;
+
+        /* Find the end of this flag (comma or end) */
+        while (p < end && *p != ',') {
+            p++;
+        }
+
+        /* Extract flag=value */
+        eq = ngx_strlchr(start, p, '=');
+        if (eq) {
+            flag_len = eq - start;
+            val_len = p - eq - 1;
+            if (flag_len >= sizeof(flag_buf)) flag_len = sizeof(flag_buf) - 1;
+            if (val_len >= sizeof(val_buf)) val_len = sizeof(val_buf) - 1;
+            ngx_memcpy(flag_buf, start, flag_len);
+            flag_buf[flag_len] = '\0';
+            ngx_memcpy(val_buf, eq + 1, val_len);
+            val_buf[val_len] = '\0';
+        } else {
+            flag_len = p - start;
+            val_len = 0;
+            if (flag_len >= sizeof(flag_buf)) flag_len = sizeof(flag_buf) - 1;
+            ngx_memcpy(flag_buf, start, flag_len);
+            flag_buf[flag_len] = '\0';
+            val_buf[0] = '\0';
+        }
+
+        /* Match flag names */
+        switch (flag_buf[0]) {
+
+        case 'B': case 'b':
+            if (flag_len == 1) {
+                rule->flags |= RULEFLAG_ESCAPEBACKREF;
+            }
+            break;
+
+        case 'C': case 'c':
+            if (flag_len == 1
+                || ngx_strncasecmp(flag_buf, (u_char *)"chain",
+                                   flag_len) == 0)
+            {
+                rule->flags |= RULEFLAG_CHAIN;
+            } else if (flag_len == 2
+                       && (flag_buf[1] == 'O' || flag_buf[1] == 'o'))
+            {
+                /* CO=cookie — Phase 2 */
+            }
+            break;
+
+        case 'D': case 'd':
+            if (flag_len == 3
+                && ngx_strncasecmp(flag_buf, (u_char *)"DPI", 3) == 0)
+            {
+                rule->flags |= RULEFLAG_DISCARDPATHINFO;
+            }
+            break;
+
+        case 'E': case 'e':
+            if (flag_len == 1
+                || ngx_strncasecmp(flag_buf, (u_char *)"env", 3) == 0)
+            {
+                /* E=VAR:VAL — add to env list */
+                if (val_len > 0) {
+                    ngx_rewrite_data_item_t *item;
+                    item = ngx_palloc(pool,
+                                      sizeof(ngx_rewrite_data_item_t));
+                    if (item == NULL) {
+                        return NGX_ERROR;
+                    }
+                    item->data.data = ngx_pnalloc(pool, val_len);
+                    if (item->data.data == NULL) {
+                        return NGX_ERROR;
+                    }
+                    ngx_memcpy(item->data.data, val_buf, val_len);
+                    item->data.len = val_len;
+                    item->next = rule->env;
+                    rule->env = item;
+                }
+            } else if (flag_len == 3
+                       && ngx_strncasecmp(flag_buf, (u_char *)"END",
+                                          3) == 0)
+            {
+                rule->flags |= RULEFLAG_END;
+            }
+            break;
+
+        case 'F': case 'f':
+            if (flag_len == 1
+                || ngx_strncasecmp(flag_buf, (u_char *)"forbidden",
+                                   flag_len) == 0)
+            {
+                rule->flags |= RULEFLAG_STATUS | RULEFLAG_NOSUB;
+                rule->forced_responsecode = NGX_HTTP_FORBIDDEN;
+            }
+            break;
+
+        case 'G': case 'g':
+            if (flag_len == 1
+                || ngx_strncasecmp(flag_buf, (u_char *)"gone",
+                                   flag_len) == 0)
+            {
+                rule->flags |= RULEFLAG_STATUS | RULEFLAG_NOSUB;
+                rule->forced_responsecode = 410;
+            }
+            break;
+
+        case 'L': case 'l':
+            if (flag_len == 1
+                || ngx_strncasecmp(flag_buf, (u_char *)"last",
+                                   flag_len) == 0)
+            {
+                rule->flags |= RULEFLAG_LASTRULE;
+            }
+            break;
+
+        case 'N': case 'n':
+            if (flag_len == 1
+                || ngx_strncasecmp(flag_buf, (u_char *)"next",
+                                   flag_len) == 0)
+            {
+                rule->flags |= RULEFLAG_NEWROUND;
+                if (val_len > 0) {
+                    rule->maxrounds = ngx_atoi(val_buf, val_len);
+                    if (rule->maxrounds == NGX_ERROR) {
+                        rule->maxrounds = NGX_REWRITE_MAX_ROUNDS;
+                    }
+                }
+            } else if (flag_len == 2
+                       && (flag_buf[1] == 'C' || flag_buf[1] == 'c'))
+            {
+                rule->flags |= RULEFLAG_NOCASE;
+            } else if (flag_len == 2
+                       && (flag_buf[1] == 'E' || flag_buf[1] == 'e'))
+            {
+                rule->flags |= RULEFLAG_NOESCAPE;
+            } else if (flag_len == 2
+                       && (flag_buf[1] == 'S' || flag_buf[1] == 's'))
+            {
+                rule->flags |= RULEFLAG_IGNOREONSUBREQ;
+            }
+            break;
+
+        case 'P': case 'p':
+            if (flag_len == 1
+                || ngx_strncasecmp(flag_buf, (u_char *)"proxy",
+                                   flag_len) == 0)
+            {
+                rule->flags |= RULEFLAG_PROXY;
+            } else if (flag_len == 2
+                       && (flag_buf[1] == 'T' || flag_buf[1] == 't'))
+            {
+                rule->flags |= RULEFLAG_PASSTHROUGH;
+            }
+            break;
+
+        case 'Q': case 'q':
+            if (flag_len == 3
+                && ngx_strncasecmp(flag_buf, (u_char *)"QSA", 3) == 0)
+            {
+                rule->flags |= RULEFLAG_QSAPPEND;
+            } else if (flag_len == 3
+                       && ngx_strncasecmp(flag_buf, (u_char *)"QSD",
+                                          3) == 0)
+            {
+                rule->flags |= RULEFLAG_QSDISCARD;
+            } else if (flag_len == 3
+                       && ngx_strncasecmp(flag_buf, (u_char *)"QSL",
+                                          3) == 0)
+            {
+                rule->flags |= RULEFLAG_QSLAST;
+            }
+            break;
+
+        case 'R': case 'r':
+            if (flag_len == 1
+                || ngx_strncasecmp(flag_buf, (u_char *)"redirect",
+                                   flag_len) == 0)
+            {
+                rule->flags |= RULEFLAG_FORCEREDIRECT;
+                if (val_len > 0) {
+                    if (ngx_strncasecmp(val_buf,
+                        (u_char *)"permanent", val_len) == 0)
+                    {
+                        rule->forced_responsecode =
+                            NGX_HTTP_MOVED_PERMANENTLY;
+                    } else if (ngx_strncasecmp(val_buf,
+                               (u_char *)"temp", val_len) == 0)
+                    {
+                        rule->forced_responsecode =
+                            NGX_HTTP_MOVED_TEMPORARILY;
+                    } else if (ngx_strncasecmp(val_buf,
+                               (u_char *)"seeother", val_len) == 0)
+                    {
+                        rule->forced_responsecode = NGX_HTTP_SEE_OTHER;
+                    } else {
+                        ngx_int_t code = ngx_atoi(val_buf, val_len);
+                        if (code >= 100 && code < 600) {
+                            rule->forced_responsecode = code;
+                            /* Non-redirect codes: set status+nosub */
+                            if (code < 300 || code >= 400) {
+                                rule->flags |= RULEFLAG_STATUS
+                                              | RULEFLAG_NOSUB;
+                            }
+                        } else {
+                            ngx_log_error(NGX_LOG_WARN, pool->log, 0,
+                                "mod_rewrite: invalid redirect code "
+                                "\"%*s\"", val_len, val_buf);
+                            return NGX_ERROR;
+                        }
+                    }
+                }
+                /* Default redirect code */
+                if (rule->forced_responsecode == 0) {
+                    rule->forced_responsecode =
+                        NGX_HTTP_MOVED_TEMPORARILY;
+                }
+            }
+            break;
+
+        case 'S': case 's':
+            if (flag_len == 1
+                || ngx_strncasecmp(flag_buf, (u_char *)"skip",
+                                   flag_len) == 0)
+            {
+                if (val_len > 0) {
+                    rule->skip = ngx_atoi(val_buf, val_len);
+                    if (rule->skip == NGX_ERROR) {
+                        rule->skip = 0;
+                    }
+                }
+            }
+            break;
+
+        case 'T': case 't':
+            if (flag_len == 1
+                || ngx_strncasecmp(flag_buf, (u_char *)"type",
+                                   flag_len) == 0)
+            {
+                if (val_len > 0) {
+                    rule->forced_mimetype.data =
+                        ngx_pnalloc(pool, val_len);
+                    if (rule->forced_mimetype.data) {
+                        ngx_memcpy(rule->forced_mimetype.data,
+                                   val_buf, val_len);
+                        rule->forced_mimetype.len = val_len;
+                    }
+                }
+            }
+            break;
+        }
+    }
+
+    return NGX_OK;
+}
+
+
+/*
+ * Parse RewriteCond flags: "[NC,OR]"
+ */
+static ngx_int_t
+ngx_http_rewrite_parse_cond_flags(ngx_conf_t *cf,
+    ngx_str_t *flags_str, ngx_rewrite_cond_t *cond)
+{
+    u_char *p, *start, *end;
+    u_char  flag_buf[64];
+    size_t  flag_len;
+
+    if (flags_str->len == 0) {
+        return NGX_OK;
+    }
+
+    p = flags_str->data;
+    end = p + flags_str->len;
+
+    while (p < end) {
+        while (p < end && (*p == ',' || *p == ' ' || *p == '\t')) {
+            p++;
+        }
+        if (p >= end) {
+            break;
+        }
+
+        start = p;
+        while (p < end && *p != ',') {
+            p++;
+        }
+
+        flag_len = p - start;
+        if (flag_len >= sizeof(flag_buf)) flag_len = sizeof(flag_buf) - 1;
+        ngx_memcpy(flag_buf, start, flag_len);
+        flag_buf[flag_len] = '\0';
+
+        if (ngx_strncasecmp(flag_buf, (u_char *)"NC", 2) == 0
+            || ngx_strncasecmp(flag_buf, (u_char *)"nocase",
+                               flag_len) == 0)
+        {
+            cond->flags |= CONDFLAG_NOCASE;
+        } else if (ngx_strncasecmp(flag_buf, (u_char *)"OR", 2) == 0
+                   || ngx_strncasecmp(flag_buf, (u_char *)"ornext",
+                                      flag_len) == 0)
+        {
+            cond->flags |= CONDFLAG_ORNEXT;
+        }
+    }
+
+    return NGX_OK;
+}
+
+
+/* ============================================================
+ *   Directive handlers
+ * ============================================================ */
+
+/*
+ * RewriteEngine on|off
+ */
+static char *
+ngx_http_rewrite_engine(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_str_t                          *value;
+    ngx_http_apache_rewrite_srv_conf_t *sconf = NULL;
+    ngx_http_apache_rewrite_loc_conf_t *lcf = NULL;
+
+    value = cf->args->elts;
+
+    /* Определяем контекст: проверяем cmd_type */
+    if (cf->cmd_type & NGX_HTTP_LOC_CONF) {
+        /* Location контекст */
+        lcf = ngx_http_conf_get_module_loc_conf(cf,
+                    ngx_http_apache_rewrite_module);
+        if (lcf == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        if (ngx_strcasecmp(value[1].data, (u_char *) "on") == 0) {
+            lcf->state = ENGINE_ENABLED;
+            lcf->state_set = 1;
+        } else if (ngx_strcasecmp(value[1].data, (u_char *) "off") == 0) {
+            lcf->state = ENGINE_DISABLED;
+            lcf->state_set = 1;
+        } else {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                "RewriteEngine: invalid value \"%V\"", &value[1]);
+            return NGX_CONF_ERROR;
+        }
+
+    } else if (cf->cmd_type & NGX_HTTP_SRV_CONF) {
+        /* Server контекст */
+        sconf = ngx_http_conf_get_module_srv_conf(cf,
+                    ngx_http_apache_rewrite_module);
+        if (sconf == NULL) {
+            return NGX_CONF_OK;
+        }
+
+        if (ngx_strcasecmp(value[1].data, (u_char *) "on") == 0) {
+            sconf->state = ENGINE_ENABLED;
+            sconf->state_set = 1;
+        } else if (ngx_strcasecmp(value[1].data, (u_char *) "off") == 0) {
+            sconf->state = ENGINE_DISABLED;
+            sconf->state_set = 1;
+        } else {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                "RewriteEngine: invalid value \"%V\"", &value[1]);
+            return NGX_CONF_ERROR;
+        }
+
+    } else if (cf->cmd_type & NGX_HTTP_MAIN_CONF) {
+        /* Main контекст */
+        if (ngx_strcasecmp(value[1].data, (u_char *) "on") == 0) {
+            sconf = ngx_http_conf_get_module_srv_conf(cf,
+                        ngx_http_apache_rewrite_module);
+            lcf = ngx_http_conf_get_module_loc_conf(cf,
+                        ngx_http_apache_rewrite_module);
+            if (sconf && lcf) {
+                sconf->state = ENGINE_ENABLED;
+                sconf->state_set = 1;
+                lcf->state = ENGINE_ENABLED;
+                lcf->state_set = 1;
+            }
+        } else if (ngx_strcasecmp(value[1].data, (u_char *) "off") == 0) {
+            sconf = ngx_http_conf_get_module_srv_conf(cf,
+                        ngx_http_apache_rewrite_module);
+            lcf = ngx_http_conf_get_module_loc_conf(cf,
+                        ngx_http_apache_rewrite_module);
+            if (sconf && lcf) {
+                sconf->state = ENGINE_DISABLED;
+                sconf->state_set = 1;
+                lcf->state = ENGINE_DISABLED;
+                lcf->state_set = 1;
+            }
+        } else {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                "RewriteEngine: invalid value \"%V\"", &value[1]);
+            return NGX_CONF_ERROR;
+        }
+
+    } else {
+        /* Непредвиденный контекст */
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+            "RewriteEngine: unexpected context");
+        return NGX_CONF_ERROR;
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+/*
+ * Helper: strip surrounding brackets [...]
+ */
+static void
+ngx_rewrite_strip_brackets(ngx_str_t *s)
+{
+    if (s->len >= 2 && s->data[0] == '['
+        && s->data[s->len - 1] == ']')
+    {
+        s->data++;
+        s->len -= 2;
+    }
+}
+
+
+/*
+ * RewriteRule pattern substitution [flags]
+ */
+static char *
+ngx_http_rewrite_rule(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+
+    ngx_http_apache_rewrite_srv_conf_t *sconf;
+    ngx_http_apache_rewrite_loc_conf_t *lcf;
+
+    sconf = ngx_http_conf_get_module_srv_conf(cf,
+                ngx_http_apache_rewrite_module);
+    lcf = ngx_http_conf_get_module_loc_conf(cf,
+                ngx_http_apache_rewrite_module);
+
+    void *result = ngx_http_rewrite_rule_helper(0, sconf,
+        lcf, cf, NULL, NULL);
+
+    if (result != NULL) {
+        return result;
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+/*
+ * RewriteCond teststring condpattern [flags]
+ */
+static char *
+ngx_http_rewrite_cond(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+
+    ngx_http_apache_rewrite_srv_conf_t *sconf;
+    ngx_http_apache_rewrite_loc_conf_t *lcf;
+
+    sconf = ngx_http_conf_get_module_srv_conf(cf,
+                ngx_http_apache_rewrite_module);
+    lcf = ngx_http_conf_get_module_loc_conf(cf,
+                ngx_http_apache_rewrite_module);
+
+    void * result = ngx_http_rewrite_cond_helper(0, sconf,
+        lcf, cf, NULL, NULL);
+
+    if (result != NULL) {
+        return result;
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+/*
+ * RewriteBase /path
+ */
+static char *
+ngx_http_rewrite_base(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_http_apache_rewrite_loc_conf_t *lcf = conf;
+    ngx_str_t                          *value;
+
+    value = cf->args->elts;
+
+    if (value[1].len == 0 || value[1].data[0] != '/') {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+            "RewriteBase: argument must start with '/'");
+        return NGX_CONF_ERROR;
+    }
+
+    lcf->baseurl = value[1];
+    lcf->baseurl_set = 1;
+
+    return NGX_CONF_OK;
+}
+
+
+/*
+ * RewriteOptions option ...
+ */
+static char *
+ngx_http_rewrite_options(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_str_t                          *value;
+    ngx_uint_t                          i;
+    ngx_http_apache_rewrite_srv_conf_t *sconf = NULL;
+    ngx_http_apache_rewrite_loc_conf_t *lcf = NULL;
+
+    value = cf->args->elts;
+
+    /* Определяем контекст: проверяем cmd_type */
+    if (cf->cmd_type & NGX_HTTP_LOC_CONF) {
+        /* Location контекст */
+        lcf = ngx_http_conf_get_module_loc_conf(cf,
+                    ngx_http_apache_rewrite_module);
+        if (lcf == NULL) {
+            return NGX_CONF_OK;
+        }
+
+        for (i = 1; i < cf->args->nelts; i++) {
+            if (ngx_strcasecmp(value[i].data, (u_char *) "Inherit") == 0) {
+                lcf->options |= OPTION_INHERIT;
+                lcf->options_set = 1;
+            } else if (ngx_strcasecmp(value[i].data,
+                       (u_char *) "InheritBefore") == 0)
+            {
+                lcf->options |= OPTION_INHERIT | OPTION_INHERIT_BEFORE;
+                lcf->options_set = 1;
+            } else {
+                ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
+                    "RewriteOptions: unknown option \"%V\"", &value[i]);
+            }
+        }
+
+    } else if (cf->cmd_type & NGX_HTTP_SRV_CONF) {
+        /* Server контекст */
+        sconf = ngx_http_conf_get_module_srv_conf(cf,
+                    ngx_http_apache_rewrite_module);
+        if (sconf == NULL) {
+            return NGX_CONF_OK;
+        }
+
+        for (i = 1; i < cf->args->nelts; i++) {
+            if (ngx_strcasecmp(value[i].data, (u_char *) "Inherit") == 0) {
+                sconf->options |= OPTION_INHERIT;
+                sconf->options_set = 1;
+            } else if (ngx_strcasecmp(value[i].data,
+                       (u_char *) "InheritBefore") == 0)
+            {
+                sconf->options |= OPTION_INHERIT | OPTION_INHERIT_BEFORE;
+                sconf->options_set = 1;
+            } else {
+                ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
+                    "RewriteOptions: unknown option \"%V\"", &value[i]);
+            }
+        }
+
+    } else if (cf->cmd_type & NGX_HTTP_MAIN_CONF) {
+        /* Main контекст */
+        sconf = ngx_http_conf_get_module_srv_conf(cf,
+                    ngx_http_apache_rewrite_module);
+        lcf = ngx_http_conf_get_module_loc_conf(cf,
+                    ngx_http_apache_rewrite_module);
+
+        for (i = 1; i < cf->args->nelts; i++) {
+            if (ngx_strcasecmp(value[i].data, (u_char *) "Inherit") == 0) {
+                if (sconf) {
+                    sconf->options |= OPTION_INHERIT;
+                    sconf->options_set = 1;
+                }
+                if (lcf) {
+                    lcf->options |= OPTION_INHERIT;
+                    lcf->options_set = 1;
+                }
+            } else if (ngx_strcasecmp(value[i].data,
+                       (u_char *) "InheritBefore") == 0)
+            {
+                if (sconf) {
+                    sconf->options |= OPTION_INHERIT | OPTION_INHERIT_BEFORE;
+                    sconf->options_set = 1;
+                }
+                if (lcf) {
+                    lcf->options |= OPTION_INHERIT | OPTION_INHERIT_BEFORE;
+                    lcf->options_set = 1;
+                }
+            } else {
+                ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
+                    "RewriteOptions: unknown option \"%V\"", &value[i]);
+            }
+        }
+
+    } else {
+        /* Непредвиденный контекст */
+        ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
+            "RewriteOptions: unexpected context");
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+/*
+ * RewriteMap name type:source
+ * Example: RewriteMap lc int:tolower
+ */
+static char *
+ngx_http_rewrite_map(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_http_apache_rewrite_srv_conf_t *sconf = conf;
+    ngx_str_t                          *value;
+    ngx_rewrite_map_entry_t            *map;
+    u_char                             *colon;
+
+    value = cf->args->elts;
+
+    map = ngx_array_push(sconf->maps);
+    if (map == NULL) {
+        return NGX_CONF_ERROR;
+    }
+    ngx_memzero(map, sizeof(ngx_rewrite_map_entry_t));
+
+    map->name = value[1];
+
+    /* Parse type:source */
+    colon = ngx_strlchr(value[2].data,
+                        value[2].data + value[2].len, ':');
+    if (colon == NULL) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+            "RewriteMap: type:source format expected, got \"%V\"",
+            &value[2]);
+        return NGX_CONF_ERROR;
+    }
+
+    {
+        ngx_str_t  type_str;
+        type_str.data = value[2].data;
+        type_str.len = colon - value[2].data;
+
+        map->source.data = colon + 1;
+        map->source.len = value[2].len - type_str.len - 1;
+
+        if (ngx_strncasecmp(type_str.data, (u_char *) "int", 3) == 0) {
+            map->type = MAPTYPE_INT;
+
+            /* Resolve internal function */
+            if (ngx_strncasecmp(map->source.data,
+                (u_char *) "tolower", 7) == 0)
+            {
+                map->func = ngx_rewrite_map_tolower;
+            } else if (ngx_strncasecmp(map->source.data,
+                       (u_char *) "toupper", 7) == 0)
+            {
+                map->func = ngx_rewrite_map_toupper;
+            } else if (ngx_strncasecmp(map->source.data,
+                       (u_char *) "escape", 6) == 0)
+            {
+                map->func = ngx_rewrite_map_escape;
+            } else if (ngx_strncasecmp(map->source.data,
+                       (u_char *) "unescape", 8) == 0)
+            {
+                map->func = ngx_rewrite_map_unescape;
+            } else {
+                ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                    "RewriteMap: unknown int function \"%V\"",
+                    &map->source);
+                return NGX_CONF_ERROR;
+            }
+        } else if (ngx_strncasecmp(type_str.data,
+                   (u_char *) "txt", 3) == 0)
+        {
+            map->type = MAPTYPE_TXT;
+            ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
+                "RewriteMap: txt maps not yet supported");
+        } else if (ngx_strncasecmp(type_str.data,
+                   (u_char *) "rnd", 3) == 0)
+        {
+            map->type = MAPTYPE_RND;
+            ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
+                "RewriteMap: rnd maps not yet supported");
+        } else if (ngx_strncasecmp(type_str.data,
+                   (u_char *) "prg", 3) == 0)
+        {
+            map->type = MAPTYPE_PRG;
+            ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
+                "RewriteMap: prg maps not yet supported");
+        } else {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                "RewriteMap: unknown map type \"%V\"", &type_str);
+            return NGX_CONF_ERROR;
+        }
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+/*
+ * HtaccessEnable on|off — enable/disable .htaccess parsing
+ */
+static char *
+ngx_http_htaccess_enable(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_str_t                          *value;
+    ngx_http_apache_rewrite_srv_conf_t *sconf;
+
+    value = cf->args->elts;
+
+
+    sconf = ngx_http_conf_get_module_srv_conf(cf,
+                ngx_http_apache_rewrite_module);
+    if (sconf == NULL) {
+        return NGX_CONF_OK; /* skip action when no server config available */
+    }
+
+    if (ngx_strcasecmp(value[1].data, (u_char *) "on") == 0) {
+        sconf->htaccess_enable = 1;
+        sconf->htaccess_enable_set = 1;
+    } else if (ngx_strcasecmp(value[1].data, (u_char *) "off") == 0) {
+        sconf->htaccess_enable = 0;
+        sconf->htaccess_enable_set = 1;
+    } else {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+            "HtaccessEnable: invalid value \"%V\"", &value[1]);
+        return NGX_CONF_ERROR;
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+/*
+ * HtaccessName <filename> — set alternative filename for htaccess file
+ */
+static char *
+ngx_http_htaccess_name(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_str_t                          *value;
+    ngx_http_apache_rewrite_srv_conf_t *sconf;
+
+    sconf = ngx_http_conf_get_module_srv_conf(cf,
+                ngx_http_apache_rewrite_module);
+
+    value = cf->args->elts;
+
+    if (sconf == NULL) {
+        return NGX_CONF_OK; /* skip action when no server config available */
+    }
+
+    if (value[1].len == 0) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+            "HtaccessName: argument must not be empty");
+        return NGX_CONF_ERROR;
+    }
+
+    sconf->htaccess_name = value[1];
+    sconf->htaccess_name_set = 1;
+
+    return NGX_CONF_OK;
+}
+
+
+/*
+ * FallbackToIndex on|off — enable automatic fallback to index.php with query string
+ * when try_files fails (transformation result file not found)
+ */
+static char *
+ngx_http_fallback_to_index(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_str_t                          *value;
+    ngx_http_apache_rewrite_srv_conf_t *sconf;
+
+    value = cf->args->elts;
+
+    sconf = ngx_http_conf_get_module_srv_conf(cf,
+                ngx_http_apache_rewrite_module);
+
+    if (sconf == NULL) {
+        return NGX_CONF_OK; /* skip action when no server config available */
+    }
+
+    if (ngx_strcasecmp(value[1].data, (u_char *) "on") == 0) {
+        sconf->fallback_to_index = 1;
+        sconf->fallback_to_index_set = 1;
+    } else if (ngx_strcasecmp(value[1].data, (u_char *) "off") == 0) {
+        sconf->fallback_to_index = 0;
+        sconf->fallback_to_index_set = 1;
+    } else {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+            "FallbackToIndex: invalid value \"%V\"", &value[1]);
+        return NGX_CONF_ERROR;
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+/*
+ * Apply FallbackToIndex logic in URL register hook.
+ * If file exists after transformation → proceed normally.
+ * If file missing → redirect to fallback_path (from RewriteFallBack in .htaccess or /index.php).
+ */
+static ngx_int_t
+ngx_http_apache_rewrite_url_register_hook_with_fallback(ngx_http_request_t *r)
+{
+    ngx_str_t          path, args, fallback_buf;
+    ngx_http_core_loc_conf_t  *clcf;
+    struct stat        st;
+    ngx_rewrite_ctx_t  *ctx;
+
+    /* Fallback enabled — check file existence first */
+
+    size_t root;
+    ngx_str_t r_path;
+    u_char *last;
+
+    ngx_int_t fallback_needed = 0;
+
+    last = ngx_http_map_uri_to_path(r, &r_path, &root, 0);
+    if (last == NULL) {
+        fallback_needed = 1;
+    } else {
+        r_path.len = last - r_path.data;
+        r_path.data = r_path.data;
+
+        u_char *r_path_null = ngx_pcalloc(r->pool, r_path.len + 1);
+        if (!r_path_null) {
+            return NGX_DECLINED;
+        }
+
+        ngx_memcpy(r_path_null, r_path.data, r_path.len);
+
+        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "mod_rewrite: fallback check for file %s",
+                       r_path_null);
+
+        if (stat((const char *)r_path_null, &st) != 0) {
+            fallback_needed = 1;
+        }
+    }
+    if (fallback_needed) {
+        clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+
+        if (clcf == NULL) {
+            return NGX_DECLINED;
+        }
+
+        /* Initialize path and args from current URI */
+        path.data = r->uri.data;
+        path.len = r->uri.len;
+        args.data = r->args.data;
+        args.len = r->args.len;
+
+        /* Get fallback path from context (from .htaccess RewriteFallBack or default /index.php) */
+        ctx = ngx_http_get_module_ctx(r, ngx_http_apache_rewrite_module);
+        if (!ctx || !ctx->fallback_path.data || ctx->fallback_path.len == 0) {
+            /* No context fallback — use default /index.php */
+            ngx_str_set(&path, "/index.php");
+            path.len = 10;
+        } else {
+            /* Use fallback path from .htaccess RewriteFallBack directive */
+            path.data = ctx->fallback_path.data;
+            path.len = ctx->fallback_path.len;
+        }
+
+        if (!args.data) {
+            ngx_http_split_args(r, &path, &args);
+        }
+
+        /* Build fallback path with query string */
+        fallback_buf.data = ngx_pnalloc(r->pool, path.len + 3 + (args.data ? args.len : 0));
+        if (fallback_buf.data == NULL) {
+            return NGX_DECLINED;
+        }
+
+        fallback_buf.len = 0;
+
+        /* Add fallback path */
+        ngx_memcpy(fallback_buf.data , path.data, path.len);
+        fallback_buf.len = path.len;
+
+        r->uri = fallback_buf;
+
+        path = r->uri;
+
+        /* Reset args for internal redirect */
+        args = r->args;
+
+        ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "mod_rewrite: fallback to \"%V?%V\" after try_files miss",
+                       &r->uri, &r->args);
+
+
+        (void)ngx_http_internal_redirect(r, &path, &args);
+        ngx_http_finalize_request(r, NGX_DONE);
+        return NGX_DONE;
+
+    } else {
+        //that means the path correct and exists
+        return NGX_DECLINED;
+    }
+
+}
diff --git a/modules/mod_rewrite/ngx_http_apache_rewrite_variable.c b/modules/mod_rewrite/ngx_http_apache_rewrite_variable.c
new file mode 100644
index 0000000..b3d7a21
--- /dev/null
+++ b/modules/mod_rewrite/ngx_http_apache_rewrite_variable.c
@@ -0,0 +1,562 @@
+/*
+ * Copyright 2026 Alexey Berezhok
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/*
+ * ngx_http_apache_rewrite_variable.c
+ *
+ * Apache mod_rewrite variable lookup for nginx.
+ * Maps %{VARNAME} to nginx request fields.
+ */
+
+#include "ngx_http_apache_rewrite_engine.h"
+
+
+/*
+ * Lookup an HTTP request header by name (case-insensitive).
+ * Converts underscores to dashes for matching.
+ */
+static ngx_str_t
+ngx_rewrite_lookup_header(ngx_http_request_t *r, ngx_str_t *name)
+{
+    ngx_list_part_t  *part;
+    ngx_table_elt_t  *h;
+    ngx_uint_t        i;
+    u_char            lowered[256];
+    ngx_uint_t        len;
+    ngx_str_t         empty = ngx_null_string;
+
+    /* Convert header name: underscores to dashes, lowercase */
+    len = name->len;
+    if (len > sizeof(lowered) - 1) {
+        len = sizeof(lowered) - 1;
+    }
+
+    for (i = 0; i < len; i++) {
+        u_char ch = name->data[i];
+        if (ch == '_') {
+            ch = '-';
+        }
+        lowered[i] = ngx_tolower(ch);
+    }
+
+    part = &r->headers_in.headers.part;
+    h = part->elts;
+
+    for (i = 0; /* void */ ; i++) {
+        if (i >= part->nelts) {
+            if (part->next == NULL) {
+                break;
+            }
+            part = part->next;
+            h = part->elts;
+            i = 0;
+        }
+
+        if (h[i].key.len == len
+            && ngx_strncasecmp(h[i].key.data, lowered, len) == 0)
+        {
+            return h[i].value;
+        }
+    }
+
+    return empty;
+}
+
+
+/*
+ * Build THE_REQUEST string: "METHOD URI PROTOCOL"
+ */
+static ngx_str_t
+ngx_rewrite_build_the_request(ngx_http_request_t *r, ngx_pool_t *pool)
+{
+    ngx_str_t  result;
+    u_char    *p;
+    size_t     len;
+
+    len = r->method_name.len + 1 + r->unparsed_uri.len + 1
+          + sizeof("HTTP/1.1") - 1;
+
+    p = ngx_pnalloc(pool, len);
+    if (p == NULL) {
+        ngx_str_null(&result);
+        return result;
+    }
+
+    result.data = p;
+    p = ngx_cpymem(p, r->method_name.data, r->method_name.len);
+    *p++ = ' ';
+    p = ngx_cpymem(p, r->unparsed_uri.data, r->unparsed_uri.len);
+    *p++ = ' ';
+
+    if (r->http_version == NGX_HTTP_VERSION_20) {
+        p = ngx_cpymem(p, "HTTP/2.0", sizeof("HTTP/2.0") - 1);
+    } else if (r->http_version == NGX_HTTP_VERSION_11) {
+        p = ngx_cpymem(p, "HTTP/1.1", sizeof("HTTP/1.1") - 1);
+    } else {
+        p = ngx_cpymem(p, "HTTP/1.0", sizeof("HTTP/1.0") - 1);
+    }
+
+    result.len = p - result.data;
+    return result;
+}
+
+
+/*
+ * Main variable lookup function.
+ * Maps Apache mod_rewrite variable names to nginx equivalents.
+ */
+ngx_str_t
+ngx_rewrite_lookup_variable(ngx_str_t *var, ngx_rewrite_ctx_t *ctx)
+{
+    ngx_http_request_t            *r = ctx->r;
+    ngx_pool_t                    *pool = r->pool;
+    ngx_str_t                      result = ngx_null_string;
+    ngx_http_core_srv_conf_t      *cscf;
+    ngx_http_core_loc_conf_t      *clcf;
+    u_char                        *p;
+    struct tm                      tm;
+    time_t                         now;
+    ngx_str_t                      hdr_name;
+
+    if (var->len == 0) {
+        return result;
+    }
+
+    /* ENV:varname — look up nginx variable */
+    if (var->len > 4
+        && ngx_strncasecmp(var->data, (u_char *) "ENV:", 4) == 0)
+    {
+        ngx_str_t                 vname;
+        ngx_uint_t                key;
+        ngx_http_variable_value_t *vv;
+
+        vname.data = var->data + 4;
+        vname.len = var->len - 4;
+        key = ngx_hash_strlow(vname.data, vname.data, vname.len);
+
+        vv = ngx_http_get_variable(r, &vname, key);
+        if (vv && !vv->not_found && vv->len > 0) {
+            result.data = vv->data;
+            result.len = vv->len;
+        }
+        return result;
+    }
+
+    /* HTTP:header — generic header lookup */
+    if (var->len > 5
+        && ngx_strncasecmp(var->data, (u_char *) "HTTP:", 5) == 0)
+    {
+        hdr_name.data = var->data + 5;
+        hdr_name.len = var->len - 5;
+        return ngx_rewrite_lookup_header(r, &hdr_name);
+    }
+
+    /* Fixed variable names — use length switch like Apache */
+    switch (var->len) {
+
+    case 4:
+        if (ngx_strncasecmp(var->data, (u_char *) "TIME", 4) == 0) {
+            now = ngx_time();
+            ngx_localtime(now, &tm);
+            p = ngx_pnalloc(pool, 15);
+            if (p) {
+                result.len = ngx_sprintf(p, "%04d%02d%02d%02d%02d%02d",
+                    tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                    tm.tm_hour, tm.tm_min, tm.tm_sec) - p;
+                result.data = p;
+            }
+            return result;
+        }
+        break;
+
+    case 5:
+        if (ngx_strncasecmp(var->data, (u_char *) "HTTPS", 5) == 0) {
+#if (NGX_SSL)
+            if (r->connection->ssl) {
+                ngx_str_set(&result, "on");
+            } else {
+                ngx_str_set(&result, "off");
+            }
+#else
+            ngx_str_set(&result, "off");
+#endif
+            return result;
+        }
+        break;
+
+    case 8:
+        if (ngx_strncasecmp(var->data, (u_char *) "TIME_DAY", 8) == 0) {
+            now = ngx_time();
+            ngx_localtime(now, &tm);
+            p = ngx_pnalloc(pool, 3);
+            if (p) {
+                result.len = ngx_sprintf(p, "%02d", tm.tm_mday) - p;
+                result.data = p;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "TIME_SEC", 8) == 0) {
+            now = ngx_time();
+            ngx_localtime(now, &tm);
+            p = ngx_pnalloc(pool, 3);
+            if (p) {
+                result.len = ngx_sprintf(p, "%02d", tm.tm_sec) - p;
+                result.data = p;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "TIME_MIN", 8) == 0) {
+            now = ngx_time();
+            ngx_localtime(now, &tm);
+            p = ngx_pnalloc(pool, 3);
+            if (p) {
+                result.len = ngx_sprintf(p, "%02d", tm.tm_min) - p;
+                result.data = p;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "TIME_MON", 8) == 0) {
+            now = ngx_time();
+            ngx_localtime(now, &tm);
+            p = ngx_pnalloc(pool, 3);
+            if (p) {
+                result.len = ngx_sprintf(p, "%02d", tm.tm_mon + 1) - p;
+                result.data = p;
+            }
+            return result;
+        }
+        break;
+
+    case 9:
+        if (ngx_strncasecmp(var->data, (u_char *) "HTTP_HOST", 9) == 0) {
+            if (r->headers_in.host) {
+                result = r->headers_in.host->value;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "IS_SUBREQ", 9) == 0) {
+            if (r->main != r) {
+                ngx_str_set(&result, "true");
+            } else {
+                ngx_str_set(&result, "false");
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "PATH_INFO", 9) == 0) {
+            /* In nginx rewrite phase there's no path_info yet */
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "TIME_HOUR", 9) == 0) {
+            now = ngx_time();
+            ngx_localtime(now, &tm);
+            p = ngx_pnalloc(pool, 3);
+            if (p) {
+                result.len = ngx_sprintf(p, "%02d", tm.tm_hour) - p;
+                result.data = p;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "TIME_WDAY", 9) == 0) {
+            now = ngx_time();
+            ngx_localtime(now, &tm);
+            p = ngx_pnalloc(pool, 2);
+            if (p) {
+                result.len = ngx_sprintf(p, "%d", tm.tm_wday) - p;
+                result.data = p;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "TIME_YEAR", 9) == 0) {
+            now = ngx_time();
+            ngx_localtime(now, &tm);
+            p = ngx_pnalloc(pool, 5);
+            if (p) {
+                result.len = ngx_sprintf(p, "%04d",
+                    tm.tm_year + 1900) - p;
+                result.data = p;
+            }
+            return result;
+        }
+        break;
+
+    case 10:
+        if (ngx_strncasecmp(var->data, (u_char *) "SERVER_URL", 10) == 0) {
+            /* Not commonly used, return empty */
+            return result;
+        }
+        break;
+
+    case 11:
+        if (ngx_strncasecmp(var->data, (u_char *) "SERVER_NAME", 11) == 0) {
+            cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
+            if (cscf) {
+                result = cscf->server_name;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "REMOTE_ADDR", 11) == 0) {
+            result = r->connection->addr_text;
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "SERVER_ADDR", 11) == 0) {
+            ngx_str_t  addr;
+            u_char     sa[NGX_SOCKADDR_STRLEN];
+
+            addr.data = sa;
+            addr.len = NGX_SOCKADDR_STRLEN;
+
+            if (ngx_connection_local_sockaddr(r->connection, &addr, 0)
+                == NGX_OK)
+            {
+                result.data = ngx_pnalloc(pool, addr.len);
+                if (result.data) {
+                    ngx_memcpy(result.data, addr.data, addr.len);
+                    result.len = addr.len;
+                }
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "THE_REQUEST", 11) == 0) {
+            return ngx_rewrite_build_the_request(r, pool);
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "HTTP_ACCEPT", 11) == 0) {
+            hdr_name.data = (u_char *) "Accept";
+            hdr_name.len = 6;
+            return ngx_rewrite_lookup_header(r, &hdr_name);
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "HTTP_COOKIE", 11) == 0) {
+            hdr_name.data = (u_char *) "Cookie";
+            hdr_name.len = 6;
+            return ngx_rewrite_lookup_header(r, &hdr_name);
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "SERVER_PORT", 11) == 0) {
+            /* Extract port from local sockaddr */
+            ngx_uint_t  port;
+            struct sockaddr *sa;
+
+            sa = r->connection->local_sockaddr;
+            port = ngx_inet_get_port(sa);
+            p = ngx_pnalloc(pool, 6);
+            if (p) {
+                result.len = ngx_sprintf(p, "%ui", port) - p;
+                result.data = p;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "REMOTE_PORT", 11) == 0) {
+            ngx_uint_t  port;
+            struct sockaddr *sa;
+
+            sa = r->connection->sockaddr;
+            port = ngx_inet_get_port(sa);
+            p = ngx_pnalloc(pool, 6);
+            if (p) {
+                result.len = ngx_sprintf(p, "%ui", port) - p;
+                result.data = p;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "REMOTE_HOST", 11) == 0) {
+            /* In nginx, REMOTE_HOST = REMOTE_ADDR (no reverse DNS) */
+            result = r->connection->addr_text;
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "REQUEST_URI", 11) == 0) {
+            result = r->unparsed_uri;
+            return result;
+        }
+        break;
+
+    case 12:
+        if (ngx_strncasecmp(var->data, (u_char *) "QUERY_STRING", 12) == 0) {
+            result = r->args;
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "HTTP_REFERER", 12) == 0) {
+            if (r->headers_in.referer) {
+                result = r->headers_in.referer->value;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "REMOTE_IDENT", 12) == 0) {
+            /* Not available in nginx */
+            return result;
+        }
+        break;
+
+    case 13:
+        if (ngx_strncasecmp(var->data, (u_char *) "DOCUMENT_ROOT", 13) == 0) {
+            clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+            if (clcf) {
+                result = clcf->root;
+            }
+            return result;
+        }
+        break;
+
+    case 14:
+        if (ngx_strncasecmp(var->data, (u_char *) "REQUEST_METHOD", 14) == 0) {
+            result = r->method_name;
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "HTTP_FORWARDED", 14) == 0) {
+            hdr_name.data = (u_char *) "Forwarded";
+            hdr_name.len = 9;
+            return ngx_rewrite_lookup_header(r, &hdr_name);
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "REQUEST_SCHEME", 14) == 0) {
+#if (NGX_SSL)
+            if (r->connection->ssl) {
+                ngx_str_set(&result, "https");
+            } else {
+                ngx_str_set(&result, "http");
+            }
+#else
+            ngx_str_set(&result, "http");
+#endif
+            return result;
+        }
+        break;
+
+    case 15:
+        if (ngx_strncasecmp(var->data, (u_char *) "HTTP_USER_AGENT", 15) == 0)
+        {
+            if (r->headers_in.user_agent) {
+                result = r->headers_in.user_agent->value;
+            }
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "SERVER_PROTOCOL", 15) == 0)
+        {
+            result = r->http_protocol;
+            return result;
+        }
+        if (ngx_strncasecmp(var->data, (u_char *) "SERVER_SOFTWARE", 15) == 0)
+        {
+            ngx_str_set(&result, NGINX_VER);
+            return result;
+        }
+        if (ngx_strncasecmp(var->data,
+            (u_char *) "SCRIPT_FILENAME", 15) == 0)
+        {
+            size_t root;
+            ngx_str_t r_path;
+            u_char *last;
+
+            // Вызываем функцию для построения полного пути
+            last = ngx_http_map_uri_to_path(r, &r_path, &root, 0);
+            if (last == NULL) {
+                clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+                if (r->uri.len > 1 && clcf != NULL) {
+                    if (r->uri.data[0] == '/') {
+                        ngx_str_t tmp_str = ngx_null_string;
+                        tmp_str.data = ngx_pnalloc(r->pool, r->uri.len);
+                        if (tmp_str.data){
+                            ngx_memzero(tmp_str.data, r->uri.len);
+                            ngx_memcpy(tmp_str.data, r->uri.data+1, r->uri.len-1);
+                            tmp_str.len = r->uri.len-1;
+                            ngx_str_t full_path = ngx_null_string;
+                            full_path.data = ngx_pnalloc(r->pool, tmp_str.len + clcf->root.len + 1);
+                            ngx_memcpy(full_path.data, clcf->root.data, clcf->root.len);
+                            ngx_memcpy(full_path.data + clcf->root.len, tmp_str.data, tmp_str.len);
+                            full_path.len = tmp_str.len + clcf->root.len + 1;
+                            result = full_path;
+                        } else {
+                            result = r->uri;
+                        }
+                    } else {
+                        ngx_str_t full_path = ngx_null_string;
+                        full_path.data = ngx_pnalloc(r->pool, r->uri.len + clcf->root.len + 1);
+                        ngx_memcpy(full_path.data, clcf->root.data, clcf->root.len);
+                        ngx_memcpy(full_path.data + clcf->root.len, r->uri.data, r->uri.len);
+                        full_path.len =r->uri.len + clcf->root.len + 1;
+                        result = full_path;
+                    }
+                } else {
+                    result = r->uri;
+                }
+            } else {
+                r_path.len = last - r_path.data;
+                r_path.data = r_path.data;
+                result = r_path;
+            }
+
+            return result;
+        }
+        break;
+
+    case 16:
+        if (ngx_strncasecmp(var->data,
+            (u_char *) "REQUEST_FILENAME", 16) == 0)
+        {
+            size_t root;
+            ngx_str_t r_path;
+            u_char *last;
+
+            last = ngx_http_map_uri_to_path(r, &r_path, &root, 0);
+            if (last == NULL) {
+                clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+                if (r->uri.len > 1 && clcf != NULL) {
+                    if (r->uri.data[0] == '/') {
+                        ngx_str_t tmp_str = ngx_null_string;
+                        tmp_str.data = ngx_pnalloc(r->pool, r->uri.len);
+                        if (tmp_str.data){
+                            ngx_memzero(tmp_str.data, r->uri.len);
+                            ngx_memcpy(tmp_str.data, r->uri.data+1, r->uri.len-1);
+                            tmp_str.len = r->uri.len-1;
+                            ngx_str_t full_path = ngx_null_string;
+                            full_path.data = ngx_pnalloc(r->pool, tmp_str.len + clcf->root.len + 1);
+                            ngx_memcpy(full_path.data, clcf->root.data, clcf->root.len);
+                            ngx_memcpy(full_path.data + clcf->root.len, tmp_str.data, tmp_str.len);
+                            full_path.len = tmp_str.len + clcf->root.len + 1;
+                            result = full_path;
+                        } else {
+                            result = r->uri;
+                        }
+                    } else {
+                        ngx_str_t full_path = ngx_null_string;
+                        full_path.data = ngx_pnalloc(r->pool, r->uri.len + clcf->root.len + 1);
+                        ngx_memcpy(full_path.data, clcf->root.data, clcf->root.len);
+                        ngx_memcpy(full_path.data + clcf->root.len, r->uri.data, r->uri.len);
+                        full_path.len =r->uri.len + clcf->root.len + 1;
+                        result = full_path;
+                    }
+                } else {
+                    result = r->uri;
+                }
+            } else {
+                r_path.len = last - r_path.data;
+                r_path.data = r_path.data;
+                result = r_path;
+            }
+
+            return result;
+        }
+        if (ngx_strncasecmp(var->data,
+            (u_char *) "CONN_REMOTE_ADDR", 16) == 0)
+        {
+            result = r->connection->addr_text;
+            return result;
+        }
+        break;
+
+    case 21:
+        if (ngx_strncasecmp(var->data,
+            (u_char *) "HTTP_PROXY_CONNECTION", 21) == 0)
+        {
+            hdr_name.data = (u_char *) "Proxy-Connection";
+            hdr_name.len = 16;
+            return ngx_rewrite_lookup_header(r, &hdr_name);
+        }
+        break;
+    }
+
+    return result;
+}
diff --git a/package_preparer.sh b/package_preparer.sh
new file mode 100644
index 0000000..2db16ab
--- /dev/null
+++ b/package_preparer.sh
@@ -0,0 +1,261 @@
+#!/bin/bash
+
+function download_nginx() {
+
+    NGINX_VER="$1"
+    CHECK_SYSTEM_NGINX="$2"
+
+    if [ -n "$CHECK_SYSTEM_NGINX" ]; then
+        if command -v rpm >/dev/null 2>&1; then
+            # rpm – выводим только версию (без релиза)
+            PKG_INFO=$(rpm -q nginx --queryformat '%{VERSION}\n' 2>/dev/null)
+        elif command -v apt-get >/dev/null 2>&1; then
+            # apt – берём «Candidate»‑версию, затем убираем часть после дефиса
+            PKG_INFO=$(apt-cache policy nginx | awk '/Candidate:/ {print $2}')
+        else
+            echo "Unsupported package manager."
+            exit 1
+        fi
+
+        # Обрезаем до первой части версии (до дефиса)
+        if [[ -n "$PKG_INFO" ]]; then
+            NGINX_VER=$(echo "$PKG_INFO" | awk -F'-' '{print $1}')
+        else
+            echo "nginx not installed."
+            exit 1
+        fi
+        if [ -z "$NGINX_VER" ]; then
+            echo "Could not determine nginx version from package manager."
+            exit 1
+        fi
+    fi
+
+    if [[ -z "$NGINX_VER" || "$NGINX_VER" == "." ]]; then
+        echo "nginx version not specified"
+        exit 1
+    fi
+
+    if [ ! -e "nginx-${NGINX_VER}" ]; then
+        wget "https://nginx.org/download/nginx-${NGINX_VER}.tar.gz" -O "nginx-${NGINX_VER}.tar.gz"
+        if [[ $? -ne 0 ]]; then
+            echo "nginx version ${NGINX_VER} not found"
+            exit 1
+        fi
+        tar xvf "nginx-${NGINX_VER}.tar.gz"
+        if [[ $? -ne 0 ]]; then
+            echo "nginx ${NGINX_VER} unpack error"
+            exit 1
+        fi
+    fi
+}
+
+COMMAND="$1"
+
+case "$COMMAND" in
+
+prepare)
+
+    DOCKER_IMAGE="$2"
+
+    if [ -z "$DOCKER_IMAGE" ]; then
+        echo "Set docker image for build"
+        exit 1
+    fi
+
+    if [ -e tmpbuild ]; then
+        rm -rf tmpbuild
+    fi
+    mkdir tmpbuild
+
+    PAK_VERSION=$(head -n 1 CHANGELOG | sed -E 's/^[[:space:]]*version:[[:space:]]*//I')
+    PAK_CHGLOG=$(awk '/^--/{flag=1;next} flag' CHANGELOG)
+    # Split PAK_VERSION into version and release
+    pkg_ver="${PAK_VERSION%%-*}"
+    pkg_rel="${PAK_VERSION##*-}"
+
+    if [ -e "$PAK_VERSION" -o -e "$PAK_CHGLOG" ]; then
+        echo "Can/t detect version or change log"
+        exit 1
+    fi
+    tar -cf "tmpbuild/nginx-mod-rewrite-$pkg_ver.tar" \
+        -C modules . \
+        --transform='s,^,nginx-mod-rewrite-'$pkg_ver'/modules/,'
+
+    tar -rf "tmpbuild/nginx-mod-rewrite-$pkg_ver.tar" \
+        -C . LICENSE package_preparer.sh \
+        --transform='s,^,nginx-mod-rewrite-'$pkg_ver'/,'
+
+    gzip -f "tmpbuild/nginx-mod-rewrite-$pkg_ver.tar"
+
+    # Copy the entire packages directory into tmpbuild
+    cp -r packages tmpbuild/
+
+    # Path to the spec file
+    SPEC_FILE="tmpbuild/packages/rpm/nginx-mod-rewrite.spec"
+
+    if [ -f "$SPEC_FILE" ]; then
+        # Replace %define version and %define release lines
+        sed -i -E "s/^%define[[:space:]]+version[[:space:]]+.*/%define version ${pkg_ver}/" "$SPEC_FILE"
+        sed -i -E "s/^%define[[:space:]]+release[[:space:]]+[0-9]+(.*)$/%define release ${pkg_rel}\1/" "$SPEC_FILE"
+
+        # Append changelog
+        cat <<EOF >> "$SPEC_FILE"
+$PAK_CHGLOG
+EOF
+    else
+        echo "Spec file $SPEC_FILE not found"
+        exit 1
+    fi
+
+    # Debian package changelog processing
+    DEB_CHANGELOG_FILE="tmpbuild/packages/deb/changelog"
+    if [ -f "$DEB_CHANGELOG_FILE" ]; then
+        cat > "$DEB_CHANGELOG_FILE" <<EOF
+$(awk -v pkg_ver="$pkg_ver" -v pkg_rel="$pkg_rel" '
+BEGIN { pkg="nginx-mod-rewrite" }
+{
+  if ($0 ~ /^\*/) {
+    if (prev) {
+      print " -- " author " " email "  " date
+      print ""
+    }
+    split($0, a, " ")
+    date=a[2]" "a[3]" "a[4]" "a[5]
+    author=a[6]" "a[7]
+    email=a[8]
+    print pkg " (" pkg_ver "-" pkg_rel ") unstable; urgency=medium"
+    print ""
+    prev=1
+  } else if ($0 ~ /^-/) {
+    sub(/^- /,"  * ",$0)
+    print $0
+  }
+}
+END {
+  if (prev) {
+    print " -- " author " " email "  " date
+    print ""
+  }
+}
+' <<< "$PAK_CHGLOG")
+EOF
+    else
+        echo "Debian changelog file $DEB_CHANGELOG_FILE not found"
+        exit 1
+    fi
+    mkdir -p tmpbuild/packages/deb/debian
+
+    # Move all files and directories from tmpbuild/packages/deb/ except the debian subdirectory
+    find tmpbuild/packages/deb -mindepth 1 -maxdepth 1 ! -name debian -exec mv {} tmpbuild/packages/deb/debian/ \;
+
+    cp package_preparer.sh tmpbuild/
+
+    # Copy Dockerfile into tmpbuild and replace placeholder image name
+    cp packages/Dockerfile tmpbuild/Dockerfile
+    sed -i "s|^FROM image|FROM ${DOCKER_IMAGE}|g" tmpbuild/Dockerfile
+
+    # Build a temporary Docker image based on the provided base image
+    docker build -t tmpbuild_image -f tmpbuild/Dockerfile .
+
+    # Run the temporary container, mount tmpbuild, build the package, and capture logs
+    docker run --rm -v "$(pwd)/tmpbuild":/app/tmpbuild tmpbuild_image 2>&1 | tee "$(pwd)/tmpbuild/build.log"
+
+    # Remove the temporary image
+    docker rmi -f tmpbuild_image
+
+;;
+download)
+    download_nginx "$2" "$3"
+;;
+packageprep)
+    PKG_MGR=""
+    # Determine package manager and install nginx
+    if command -v dnf >/dev/null 2>&1; then
+        PKG_MGR="dnf"
+        $PKG_MGR install -y nginx openssl-devel pcre-devel zlib-devel rpm-build gcc gcc-c++ make wget
+    elif command -v yum >/dev/null 2>&1; then
+        PKG_MGR="yum"
+        $PKG_MGR install -y nginx openssl-devel pcre-devel zlib-devel rpm-build gcc gcc-c++ make wget
+    elif command -v apt-get >/dev/null 2>&1; then
+        PKG_MGR="apt-get"
+        apt-get update
+        $PKG_MGR install -y nginx debhelper-compat dh-autoreconf libssl-dev libpcre2-dev zlib1g-dev make gcc build-essential wget
+    else
+        echo "Unsupported package manager."
+        exit 1
+    fi
+
+    if [ "$PKG_MGR" == "yum" -o "$PKG_MGR" == "dnf" ]; then
+        mkdir -p rpmbuild/BUILD rpmbuild/BUILDROOT rpmbuild/RPMS rpmbuild/SOURCES rpmbuild/SPECS rpmbuild/SRPMS
+        cp packages/rpm/nginx-mod-rewrite.spec rpmbuild/SPECS
+        cp nginx-mod-rewrite-*.tar.gz rpmbuild/SOURCES
+        rpmbuild --define='_topdir /app/rpmbuild' -ba rpmbuild/SPECS/nginx-mod-rewrite.spec
+        cp rpmbuild/RPMS/x86_64/* /app/tmpbuild
+        cp rpmbuild/SRPMS/* /app/tmpbuild
+    else
+
+        # Find the tarball file
+        TARBALL=$(ls -1 nginx-mod-rewrite-*.tar.gz 2>/dev/null | head -n 1)
+        if [ -z "$TARBALL" ]; then
+            echo "No tar.gz file found matching pattern."
+            exit 1
+        fi
+
+        # Copy tarball to packages/deb
+        cp "$TARBALL" packages/deb/
+
+        # Store current directory
+        CUR_DIR=$(pwd)
+
+        # Change to packages/deb
+        cd packages/deb || exit 1
+
+        # Extract, stripping the top-level directory
+        tar --strip-components=1 -xzf "$(basename "$TARBALL")"
+
+        dpkg-buildpackage -us -uc
+
+        cp ../nginx-mod-rewrite* /app/tmpbuild
+
+        # Return to original directory
+        cd "$CUR_DIR" || exit 1
+    fi
+;;
+build)
+    # Get nginx configuration arguments
+    if ! command -v nginx >/dev/null 2>&1; then
+        echo "nginx is not installed."
+        exit 1
+    fi
+
+    NGINX_VER_OUTPUT=$(nginx -V 2>&1)
+    CONFIG_ARGS=$(echo "$NGINX_VER_OUTPUT" | awk -F'configure arguments: ' '{print $2}')
+    if [ -z "$CONFIG_ARGS" ]; then
+        echo "Could not retrieve nginx configuration arguments."
+        exit 1
+    fi
+
+    echo "Retrieved configure arguments: $CONFIG_ARGS"
+
+    # Change to nginx source directory
+    SRC_DIR=$(ls -d nginx-* 2>/dev/null | head -n 1)
+    if [ -z "$SRC_DIR" ]; then
+        echo "Nginx source directory not found."
+        exit 1
+    fi
+    cd "$SRC_DIR" || exit 1
+
+    # Run configure with saved arguments and add mod_rewrite
+    read -ra CONFIG_ARRAY <<< "$CONFIG_ARGS"
+    ./configure "${CONFIG_ARRAY[@]}" --add-dynamic-module=../modules/mod_rewrite
+    make modules
+    cp objs/ngx_http_apache_rewrite_module.so ../
+;;
+*)
+    echo "Incorrect command"
+    exit 1
+;;
+
+esac
+
+exit 0
diff --git a/packages/deb/README.build b/packages/deb/README.build
new file mode 100644
index 0000000..0b47ec6
--- /dev/null
+++ b/packages/deb/README.build
@@ -0,0 +1,68 @@
+# Как собрать Debian пакет nginx-mod-rewrite
+
+## Программа для сборки пакета
+
+Для сборки Debian/Ubuntu пакетов используется инструмент **`dpkg-buildpackage`**.
+
+```bash
+cd /home/alexey/projects/workspace-zed/test1/packages/deb
+dpkg-buildpackage -us -uc
+```
+
+Альтернативные команды:
+- `debbuild` или `debuild` - обёртки для dpkg-buildpackage
+- `fakeroot debian/rules binary` - ручной запуск сборки (для опытных пользователей)
+
+## Зависимости для сборки
+
+Перед сборкой установите необходимые пакеты:
+
+```bash
+sudo apt install debhelper-compat dh-autoreconf nginx build-essential
+```
+
+## Процесс сборки
+
+1. `dpkg-buildpackage` запускает debian/rules правила
+2. `dh` (debhelper) автоматически выполняет стандартные этапы: configure, build, install
+3. Ваш скрипт package_preparer.sh скачивает исходный код nginx и компилирует модуль
+4. Скрипты postinst/postrm обрабатывают установку/удаление в системе
+
+## Результат
+
+После успешной сборки будет создан `.deb` файл:
+- `nginx-mod-rewrite_0.1-1_amd64.deb` - пакет для установки
+
+## Установка пакета
+
+```bash
+sudo dpkg -i nginx-mod-rewrite_0.1-1_amd64.deb
+```
+
+## Структура файлов в Debian пакете
+
+| Путь | Описание |
+|------|----------|
+| `debian/control` | Метаданные пакета (имя, версия, зависимости) |
+| `debian/changelog` | История изменений пакета |
+| `debian/rules` | Скрипт сборки (makefile-like) |
+| `debian/copyright` | Информация об авторских правах и лицензии |
+| `debian/postinst` | Пост-скрипт установки (reload nginx после инсталляции) |
+| `debian/postrm` | Пост-скрипт удаления (очистка конфига nginx) |
+| `debian/triggers` | Триггеры для динамического обновления nginx модулей |
+| `modules/mod_rewrite/*` | Исходный код модуля rewrite |
+
+## Отличия от RPM spec
+
+| RPM (`nginx-mod-rewrite.spec`) | Debian (`debian/`) |
+|-------------------------------|-------------------|
+| `%define`, `%description` | `debian/control` |
+| `%prep`, `%build`, `%install` | `debian/rules + dh` |
+| `%post`, `%preinst` | `debian/postinst`, `debian/preinst` |
+| rpmbuild | dpkg-buildpackage |
+
+## Запуск сборки
+
+```bash
+cd /home/alexey/projects/workspace-zed/test1/packages/deb
+dpkg-buildpackage -us -uc -A  # Не подписываем, не используем чужие ключи, только архитектура
diff --git a/packages/deb/changelog b/packages/deb/changelog
new file mode 100644
index 0000000..cc0e717
--- /dev/null
+++ b/packages/deb/changelog
@@ -0,0 +1,5 @@
+nginx-mod-rewrite (0.1-1) unstable; urgency=medium
+
+  * New upstream release
+
+ -- Alexey Berezhok <a@bayrepo.ru>  Fri, 13 Mar 2026 00:00:00 +0000
diff --git a/packages/deb/control b/packages/deb/control
new file mode 100644
index 0000000..30dc4b7
--- /dev/null
+++ b/packages/deb/control
@@ -0,0 +1,21 @@
+Source: nginx-mod-rewrite
+Section: web
+Priority: optional
+Maintainer: Alexey Berezhok <a@bayrepo.ru>
+Build-Depends: debhelper-compat (=13),
+       dh-autoreconf,
+       libssl-dev,
+       libpcre2-dev,
+       zlib1g-dev,
+       nginx (>= 1.4.0)
+Standards-Version: 4.7.0
+Homepage: https://docs.brepo.ru/nginx-mod-rewrite
+
+Package: nginx-mod-rewrite
+Architecture: any
+Depends: ${shlibs:Depends}, nginx
+Provides: nginx-http-module, nginx-apache-rewrite
+Description: Nginx rewrite module – dynamic module adding mod_rewrite functionality
+ Dynamic Nginx module implementing Apache mod_rewrite functionality.
+ The package is built from Nginx sources and the module's own files, and then
+ installs only the compiled shared object into /etc/nginx/modules directory.
diff --git a/packages/deb/copyright b/packages/deb/copyright
new file mode 100644
index 0000000..cda29c2
--- /dev/null
+++ b/packages/deb/copyright
@@ -0,0 +1,26 @@
+Format: 1.0
+Upstream-Name: nginx-mod-rewrite
+Upstream-Contact: Alexey Berezhok <a@bayrepo.ru>
+Source: https://docs.brepo.ru/nginx-mod-rewrite
+
+Files: *
+Copyright: (c) 2026 Alexey Berezhok, All Rights Reserved.
+License: Apache-2.0
+
+Files: nginx-*/*
+Copyright: (c) 2002-2021 Igor Sysoev
+         (c) 2011-2021 Nginx, Inc., All Rights Reserved.
+License: BSD-3-Clause
+
+Documentation: docs/README.md
+Files: modules/mod_rewrite/*.c modules/mod_rewrite/*.h
+Copyright: (c) 2026 Alexey Berezhok, All Rights Reserved.
+License: Apache-2.0
+
+
+====
+====
+
+====
+
+====
diff --git a/packages/deb/postinst b/packages/deb/postinst
new file mode 100755
index 0000000..c9b852c
--- /dev/null
+++ b/packages/deb/postinst
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# Pre-installation script - check nginx is available
+set -e
+
+if ! command -v dpkg >/dev/null 2>&1; then
+    echo "dpkg not found." >&2
+    exit 1
+fi
+
+if [ "$1" = "configure" ] || [ "$1" = "abort-upgrade" ]; then
+    # Verify nginx is installed before proceeding
+    if ! command -v nginx >/dev/null 2>&1; then
+        echo "nginx is required for nginx-mod-rewrite." >&2
+        exit 1
+    fi
+
+    # Check nginx module configuration directory exists
+    if [ ! -d /etc/nginx/modules ]; then
+        mkdir -p /etc/nginx/modules || true
+    fi
+fi
+
+exit 0
diff --git a/packages/deb/postrm b/packages/deb/postrm
new file mode 100755
index 0000000..30a6414
--- /dev/null
+++ b/packages/deb/postrm
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+# Post-removal script - clean up nginx module configuration
+set -e
+
+if [ "$1" = "purge" ]; then
+    # Remove module config file if it exists
+    rm -f /etc/nginx/modules/ngx_http_apache_rewrite_module.conf || true
+
+    # Optionally reload nginx to remove unneeded modules from memory
+    if command -v systemctl >/dev/null 2>&1; then
+        systemctl reload nginx.service >/dev/null 2>&1 || true
+    fi
+
+    # Alternative for non-systemd systems
+    if command -v nginx >/dev/null 2>&1; then
+        nginx -s reload >/dev/null 2>&1 || true
+    fi
+fi
+
+exit 0
diff --git a/packages/deb/rules b/packages/deb/rules
new file mode 100755
index 0000000..255b982
--- /dev/null
+++ b/packages/deb/rules
@@ -0,0 +1,28 @@
+#!/usr/bin/make -f
+
+# Set debhelper compat level
+DEBHELPER_COMPAT = 13
+
+export DH_COMPAT=$(DEBHELPER_COMPAT)
+export BUILD_DIR = debian/build
+export INSTALDIR = debian/nginx-mod-rewrite/usr/share/nginx/modules
+export CONFFDIR = debian/nginx-mod-rewrite/etc/nginx/modules
+
+# Set build options
+override_dh_auto_build:
+	bash package_preparer.sh download . system
+	bash package_preparer.sh build
+
+override_dh_auto_install:
+	mkdir -p $(INSTALDIR) $(CONFFDIR)
+	cp *.so $(INSTALDIR)/
+	echo 'load_module "$(INSTALDIR)/ngx_http_apache_rewrite_module.so";' > \
+	$(CONFFDIR)/ngx_http_apache_rewrite_module.conf
+
+override_dh_auto_clean:
+	rm -rf debian/build
+	rm -f *.so
+	rm -rf nginx-*
+
+%:
+	dh $@ --sourcedirectory=.
diff --git a/packages/deb/triggers b/packages/deb/triggers
new file mode 100644
index 0000000..503a061
--- /dev/null
+++ b/packages/deb/triggers
@@ -0,0 +1,10 @@
+# Nginx module triggers - handles nginx reloading when modules change
+
+# Trigger type: wait allows packages to install themselves after nginx reload completes
+nginx/reload-inactive {
+	nginx-reload
+}
+
+nginx/reload-active {
+	nginx-reload
+}
diff --git a/packages/rpm/nginx-mod-rewrite.spec b/packages/rpm/nginx-mod-rewrite.spec
new file mode 100644
index 0000000..1414bdd
--- /dev/null
+++ b/packages/rpm/nginx-mod-rewrite.spec
@@ -0,0 +1,58 @@
+%define name nginx-mod-rewrite
+%define version 0.1
+%define release 1%{?dist}
+%define summary "Nginx rewrite module – dynamic module adding mod_rewrite functionality"
+%define license Apache-2.0
+%define url https://docs.brepo.ru/nginx-mod-rewrite
+%define packager "Alexey Berezhok <a@bayrepo.ru>"
+%global nginx_moduledir %{_libdir}/nginx/modules
+%global nginx_moduleconfdir %{_datadir}/nginx/modules
+
+Name:           %{name}
+Version:        %{version}
+Release:        %{release}
+Summary:        %{summary}
+License:        %{license}
+URL:            %{url}
+Source0:        %{name}-%{version}.tar.gz
+
+BuildRequires:  openssl-devel
+BuildRequires:  pcre-devel
+BuildRequires:  zlib-devel
+BuildRequires:  bash
+BuildRequires:  wget
+Requires:       nginx
+
+%description
+Dynamic Nginx module implementing Apache mod_rewrite functionality.
+The package is built from Nginx sources and the module's own files, and then
+installs only the compiled shared object into the /etc/nginx/modules directory.
+
+%prep
+%setup -q
+
+%build
+bash package_preparer.sh download . system
+bash package_preparer.sh build
+
+%install
+# Install only the dynamic module
+mkdir -p %{buildroot}%{nginx_moduledir} %{buildroot}%{nginx_moduleconfdir}
+cp *.so %{buildroot}%{nginx_moduledir}
+echo 'load_module "%{nginx_moduledir}/ngx_http_apache_rewrite_module.so";' \
+    > %{buildroot}%{nginx_moduleconfdir}/ngx_http_apache_rewrite_module.conf
+
+%post
+if [ $1 -eq 1 ]; then
+    /usr/bin/systemctl reload nginx.service >/dev/null 2>&1 || :
+fi
+
+
+%files
+%license LICENSE
+
+%attr(0640,root,root) %{nginx_moduleconfdir}/ngx_http_apache_rewrite_module.conf
+%attr(0755,root,root) %{nginx_moduledir}/ngx_http_apache_rewrite_module.so
+
+
+%changelog