chore(release): Bumped to Version 16.28.0

# [16.28.0](https://github.com/frappe/erpnext/compare/v16.27.0...v16.28.0) (2026-07-15)

### Bug Fixes

* **accounts:** added permission checks on `get_account_balances_coa` (backport [#57107](https://github.com/frappe/erpnext/issues/57107)) ([#57122](https://github.com/frappe/erpnext/issues/57122)) ([e8a5325](e8a532587d))
* allow barcode scan to add and increment items in pick list ([00a646a](00a646ac25))
* apply precision fix inline for v16-hotfix, drop develop-only asset_service refactor ([d3a8e91](d3a8e91cda))
* **asset:** allow asset repair creation for fully depreciated assets ([8658039](8658039e9a))
* **budget-variance:** correct month shift in comparison chart ([703e9a7](703e9a728c))
* guard company logo lookup in default letterheads ([7b54314](7b543142a2))
* **journal-entry:** fetch outstanding on foreign currency ([ec782ee](ec782ee20d))
* **manufacturing:** preserve job card transferred quantity ([d7e9321](d7e9321746))
* match depreciation schedule rows at currency precision to avoid duplicate JEs ([a1fae95](a1fae959ed))
* prevent duplicate material request items in purchase order ([4d951c1](4d951c1cf8))
* set explicit table and logo widths in grey letterhead ([0d80fef](0d80fef3bf))
* **stock:** fix sqlparse token limit in get_bundle_wise_serial_nos ([5a99dd6](5a99dd6016))
* **stock:** set stock_uom on transferred Stock Reservation Entries ([5991ecf](5991ecfa3d))
* **stock:** show qty (company) and qty (warehouse) in sales transactions ([0d9ace7](0d9ace7ab8))
* **tnc:** `get_terms_and_conditions` render_template with `safe_exec` (backport [#56944](https://github.com/frappe/erpnext/issues/56944)) ([#56977](https://github.com/frappe/erpnext/issues/56977)) ([40c85a0](40c85a0087))

### Features

* **balance-sheet:** implement execute_synced_report with full parity to normal report ([636bcbe](636bcbedc0))
* **general-ledger:** implement execute_synced_report with full parity to normal report ([19ec095](19ec095ff8))
* **profit-and-loss:** implement execute_synced_report with full parity to normal report ([21ddb00](21ddb00e20))
* **trial-balance:** implement execute_duckdb with full parity to normal report ([228418b](228418b05f))
* weekly auto-repost of incorrect stock valuation entries (backport [#56637](https://github.com/frappe/erpnext/issues/56637)) ([#56700](https://github.com/frappe/erpnext/issues/56700)) ([bf1b7f2](bf1b7f2bea))

.github/helper/hydrate.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+#
+# Hydrate a test shard from the setup job's artifact.
+#
+# The bench (apps, venv, node_modules, sites) is already on disk at ~/frappe-bench — the
+# workflow untar'd it from the artifact the setup job built. So there is NO bench init, no
+# asset build, and no reinstall here: just bring the DB up on the baked datadir and start redis
+# so tests can run. The whole point is that the expensive work happened ONCE in the setup job.
+#
+set -e
+
+ci_user="${ERPNEXT_CI_USER:-frappe}"
+db_host="${DB_HOST:-127.0.0.1}"
+
+# Re-exec as the ci user (uid 1001) so bench/cache ownership matches the artifact, same as
+# install.sh. The workflow untar'd as root with -p, so the files are already owned by ci.
+if [ "$(id -u)" = "0" ] && [ "${SKIP_SYSTEM_SETUP:-0}" = "1" ] && [ "$ci_user" != "root" ]; then
+    exec su -m "$ci_user" -s /bin/bash -c \
+        "ERPNEXT_CI_USER='$ci_user' DB_HOST='$db_host' DB='${DB:-}' bash '$0'"
+fi
+
+cd ~/frappe-bench
+
+# Start the DB on the datadir baked into the artifact. It's already populated (the setup job
+# reinstalled into this very datadir), so there is NO restore — the server comes up on the
+# existing files. This is what replaces the per-shard SQL replay.
+bash ~/frappe-bench/start-db.sh
+
+# Bring up redis (lightmode unit tests need cache + queue). In the self-hosted container we use the
+# full `bench start` (web/workers too, like install.sh). On the bare GitHub Postgres shard
+# `bench start` (honcho) lagged — it blocks the redis procs behind web/worker procs the lightmode
+# suite never uses, so the wait below burned its full timeout (~4m). There, start the two redis
+# instances directly: fast and deterministic.
+if [ "${DB:-mariadb}" = "postgres" ]; then
+    # Start redis directly as daemons — reliable and persists across steps. Do NOT route it through
+    # `bench start`: honcho tears the whole process group down if any one Procfile proc dies on the
+    # bare shard, which took redis with it (redis @ 13000 refused in Run Tests). Keeping redis
+    # independent is what makes it survive. The web server (for PDF tests) is NOT started here — a
+    # backgrounded server doesn't survive into the next step; it's started inside the Run Tests step.
+    for conf in redis_cache redis_queue; do
+        [ -f ~/frappe-bench/config/$conf.conf ] && redis-server ~/frappe-bench/config/$conf.conf --daemonize yes
+    done
+else
+    bench start >> ~/frappe-bench/bench_start.log 2>&1 &
+fi
+
+# Wait for redis, failing fast instead of silently burning minutes if it never comes up.
+cfg=~/frappe-bench/sites/common_site_config.json
+if [ -f "$cfg" ]; then
+    ports=$(python - "$cfg" <<'PY'
+import json, re, sys
+try:
+    cfg = json.load(open(sys.argv[1]))
+except Exception:
+    sys.exit(0)
+for key in ("redis_cache", "redis_queue"):
+    m = re.search(r":(\d+)", str(cfg.get(key, "")))
+    if m:
+        print(m.group(1))
+PY
+)
+    for port in $ports; do
+        up=0
+        for _ in $(seq 1 60); do
+            if (exec 3<>"/dev/tcp/127.0.0.1/$port") 2>/dev/null; then exec 3>&- 3<&-; up=1; break; fi
+            sleep 1
+        done
+        [ "$up" = "1" ] || { echo "redis did not come up on port $port"; exit 1; }
+    done
+fi
+
+echo "Hydrated: DB up on baked datadir, redis up — ready for tests."

.github/helper/install.sh

@@ -7,21 +7,106 @@ cd ~ || exit
 githubbranch=${GITHUB_BASE_REF:-${GITHUB_REF##*/}}
 frappeuser=${FRAPPE_USER:-"frappe"}
 frappecommitish=${FRAPPE_BRANCH:-$githubbranch}
+db_host=${DB_HOST:-"127.0.0.1"}
+db_user_host=${DB_USER_HOST:-"localhost"}
+wkhtmltox_deb=${WKHTMLTOX_DEB:-"/tmp/wkhtmltox.deb"}
+bench_cache_dir=${BENCH_CACHE_DIR:-}
+
+run_as_ci_user_if_needed() {
+    if [ "$(id -u)" != "0" ] || [ "${SKIP_SYSTEM_SETUP:-0}" != "1" ] || [ "${ERPNEXT_CI_NON_ROOT:-0}" = "1" ]; then
+        return
+    fi
+
+    local missing_packages=()
+    if ! command -v pkg-config >/dev/null 2>&1; then
+        missing_packages+=("pkg-config")
+    fi
+    if ! command -v mariadb_config >/dev/null 2>&1 && ! command -v mysql_config >/dev/null 2>&1; then
+        missing_packages+=("libmariadb-dev")
+    fi
+    if ! command -v crontab >/dev/null 2>&1; then
+        missing_packages+=("cron")
+    fi
+
+    if [ "${#missing_packages[@]}" -gt 0 ]; then
+        apt-get update
+        apt-get install -y --no-install-recommends "${missing_packages[@]}"
+    fi
+
+    local ci_user="${ERPNEXT_CI_USER:-frappe}"
+
+    if ! id "$ci_user" >/dev/null 2>&1; then
+        useradd --home-dir "$HOME" --no-create-home --shell /bin/bash "$ci_user"
+    fi
+
+    rm -rf ~/frappe ~/frappe-bench
+
+    local ci_dirs=(
+        "$HOME"
+        "$GITHUB_WORKSPACE"
+        "$HOME/.cache"
+        "${PIP_CACHE_DIR:-$HOME/.cache/pip}"
+        "${npm_config_cache:-$HOME/.npm}"
+        "${YARN_CACHE_FOLDER:-$HOME/.cache/yarn}"
+        "$HOME/.yarn"
+        "${UV_CACHE_DIR:-$HOME/.cache/uv}"
+        "$(dirname "$wkhtmltox_deb")"
+    )
+    if [ -n "$bench_cache_dir" ]; then
+        ci_dirs+=("$bench_cache_dir")
+    fi
+
+    # Create + own (non-recursively) the home/cache/workspace dirs before dropping to
+    # the ci user. We deliberately do NOT wipe the yarn/uv caches here so a persistent
+    # cache (mounted volume or baked image layer) stays warm across runs.
+    mkdir -p "${ci_dirs[@]}" "$HOME/.yarn"
+    chown "$ci_user:$ci_user" "${ci_dirs[@]}" "$HOME/.yarn"
+
+    export ERPNEXT_CI_NON_ROOT=1
+    exec su -m "$ci_user" -s /bin/bash -c "cd '$HOME' && bash '$GITHUB_WORKSPACE/.github/helper/install.sh'"
+}
+
+run_as_ci_user_if_needed
+
+run_ci_step() {
+    local label=$1
+    shift
+
+    echo "::group::${label}"
+    date -u
+    local exit_code=0
+    timeout --foreground "${CI_INSTALL_STEP_TIMEOUT:-1800}" "$@" || exit_code=$?
+    date -u
+    echo "::endgroup::"
+    return "$exit_code"
+}
+
+if [ -n "${GITHUB_WORKSPACE:-}" ]; then
+    git config --global --add safe.directory "$GITHUB_WORKSPACE" || true
+    git config --global --add safe.directory "$GITHUB_WORKSPACE/.git" || true
+fi
+
+rm -rf ~/frappe ~/frappe-bench
 
 # ---------------------------------------------------------------------------
 # Phase 1 — parallelise the three slow, independent setup steps:
 #   a) system packages   b) frappe-bench pip install   c) frappe git fetch
 # ---------------------------------------------------------------------------
 
-sudo apt update
+if [ "${SKIP_SYSTEM_SETUP:-0}" != "1" ]; then
+    sudo apt-get update
 
-# apt remove/install must run sequentially but can overlap with pip and git.
-sudo apt remove mysql-server mysql-client
-sudo apt install libcups2-dev redis-server mariadb-client libmariadb-dev &
-apt_pid=$!
+    # apt remove/install must run sequentially but can overlap with pip and git.
+    sudo apt-get remove -y mysql-server mysql-client
+    sudo apt-get install -y libcups2-dev redis-server mariadb-client libmariadb-dev &
+    apt_pid=$!
 
-pip install frappe-bench &
-pip_pid=$!
+    pip install frappe-bench &
+    pip_pid=$!
+else
+    apt_pid=
+    pip_pid=
+fi
 
 mkdir frappe
 (
@@ -32,76 +117,247 @@ mkdir frappe
 ) &
 clone_pid=$!
 
-wait $apt_pid
-wait $pip_pid
+if [ -n "$apt_pid" ]; then wait $apt_pid; fi
+if [ -n "$pip_pid" ]; then wait $pip_pid; fi
 wait $clone_pid
 
 pushd frappe
 git checkout FETCH_HEAD
 popd
+frappe_sha=$(git -C frappe rev-parse HEAD)
+
+get_bench_cache_archive() {
+    if [ -z "$bench_cache_dir" ]; then
+        return
+    fi
+
+    mkdir -p "$bench_cache_dir"
+
+    # Keyed on tool versions only (NOT the frappe SHA): any recent base bench works, because
+    # restore_warm_bench fast-forwards it to the exact live develop SHA. This is what lets a
+    # constantly-moving develop still hit the cache.
+    local cache_key
+    cache_key=$(
+        {
+            uname -m
+            python --version
+            node --version
+            bench --version
+        } | sha256sum | awk '{print $1}'
+    )
+
+    echo "${bench_cache_dir}/frappe-bench-base-${cache_key}.tar.zst"
+}
+
+restore_warm_bench() {
+    bench_cache_archive=$(get_bench_cache_archive)
+    [ -n "$bench_cache_archive" ] && [ -f "$bench_cache_archive" ] || return 1
+
+    echo "Restoring base bench from ${bench_cache_archive}"
+    tar --use-compress-program=unzstd -xf "$bench_cache_archive" -C ~ || return 1
+    [ -d ~/frappe-bench/apps/frappe/.git ] || return 1
+    mkdir -p ~/frappe-bench/sites ~/frappe-bench/logs
+    [ -f ~/frappe-bench/sites/apps.txt ] || printf "frappe\n" > ~/frappe-bench/sites/apps.txt
+    [ -f ~/frappe-bench/sites/common_site_config.json ] || printf "{}\n" > ~/frappe-bench/sites/common_site_config.json
+
+    # Fast-forward the restored frappe to the EXACT live develop SHA fetched in phase 1, then
+    # rebuild only what changed. The editable install means the venv tracks the new code with
+    # no reinstall. Any failure returns non-zero so the caller falls back to a full bench init.
+    if ! (
+        cd ~/frappe-bench/apps/frappe || exit 1
+        # Phase 1 already fetched ~/frappe to the exact live develop SHA. Fetch that commit
+        # straight from it (bench init names the remote 'upstream', not 'origin', and points
+        # it at this local clone — so a plain `git fetch origin` does not work).
+        git fetch --no-tags "$HOME/frappe" HEAD || exit 1
+        git checkout --force FETCH_HEAD || exit 1
+    ); then
+        echo "Fast-forward to ${frappe_sha} failed; falling back to full init"
+        rm -rf ~/frappe-bench
+        return 1
+    fi
+
+    # Pick up any frappe dependency changes since the base was built (cached → fast if none),
+    # so a develop commit that bumped requirements doesn't leave a stale venv.
+    if ! ~/frappe-bench/env/bin/python -m pip install -q -e ~/frappe-bench/apps/frappe; then
+        echo "frappe dependency refresh failed; falling back to full init"
+        rm -rf ~/frappe-bench
+        return 1
+    fi
+
+    ( cd ~/frappe-bench && CI=Yes bench build --app frappe ) || { rm -rf ~/frappe-bench; return 1; }
+    return 0
+}
+
+save_warm_bench() {
+    if [ -z "${bench_cache_archive:-}" ] || [ -f "$bench_cache_archive" ]; then
+        return
+    fi
+
+    if [ -n "$bench_cache_dir" ] && [ ! -w "$bench_cache_dir" ]; then
+        echo "Skipping warm bench save because ${bench_cache_dir} is not writable"
+        return
+    fi
+
+    local tmp_archive
+    tmp_archive="${bench_cache_archive}.${$}.tmp"
+
+    echo "Saving warm bench to ${bench_cache_archive}"
+    # Keep sites/common_site_config.json (the redis ports live there — dropping it makes the
+    # restore path fall back to a default redis port that bench start never bound, so reinstall
+    # fails with "redis ... connection refused"). Only the rebuildable sites/assets is excluded;
+    # restore_warm_bench runs `bench build` to regenerate it.
+    tar \
+        --use-compress-program="zstd -T0 -3" \
+        --exclude="frappe-bench/logs" \
+        --exclude="frappe-bench/sites/assets" \
+        -cf "$tmp_archive" \
+        -C ~ frappe-bench
+    mv "$tmp_archive" "$bench_cache_archive"
+}
 
 # ---------------------------------------------------------------------------
 # Phase 2 — bench init and site setup
 # ---------------------------------------------------------------------------
 
-bench init --skip-assets --frappe-path ~/frappe --python "$(which python)" frappe-bench
+install_whktml() {
+    # Re-use the .deb if the wkhtmltopdf cache step already restored it.
+    if [ ! -f "$wkhtmltox_deb" ]; then
+        wget -O "$wkhtmltox_deb" https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
+    fi
+    sudo apt-get install -y "$wkhtmltox_deb"
+}
+if [ "${SKIP_WKHTMLTOX_SETUP:-0}" != "1" ]; then
+    install_whktml &
+    wkpid=$!
+else
+    wkpid=
+fi
 
-mkdir ~/frappe-bench/sites/test_site
+if ! restore_warm_bench; then
+    bench init --skip-assets --frappe-path ~/frappe --python "$(which python)" frappe-bench
+
+    cd ~/frappe-bench || exit
+
+    sed -i 's/watch:/# watch:/g' Procfile
+    sed -i 's/schedule:/# schedule:/g' Procfile
+    sed -i 's/socketio:/# socketio:/g' Procfile
+    sed -i 's/redis_socketio:/# redis_socketio:/g' Procfile
+
+    CI=Yes bench build --app frappe
+    save_warm_bench
+fi
+
+if [ -n "$wkpid" ]; then wait $wkpid; fi
+
+mkdir -p ~/frappe-bench/sites/test_site
 
 if [ "$DB" == "mariadb" ];then
     cp -r "${GITHUB_WORKSPACE}/.github/helper/site_config_mariadb.json" ~/frappe-bench/sites/test_site/site_config.json
+    if [ "$db_host" != "127.0.0.1" ]; then
+        sed -i "s/\"db_host\": \"127.0.0.1\"/\"db_host\": \"${db_host}\"/" ~/frappe-bench/sites/test_site/site_config.json
+    fi
 else
     cp -r "${GITHUB_WORKSPACE}/.github/helper/site_config_postgres.json" ~/frappe-bench/sites/test_site/site_config.json
 fi
 
 
 if [ "$DB" == "mariadb" ];then
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL character_set_server = 'utf8mb4'"
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL collation_server = 'utf8mb4_unicode_ci'"
+    for _ in {1..60}; do
+        if mariadb-admin ping --host "$db_host" --port 3306 -u root -proot --silent; then
+            break
+        fi
+        sleep 1
+    done
+    mariadb-admin ping --host "$db_host" --port 3306 -u root -proot --silent
 
-    # Belt-and-suspenders: also set performance variables at runtime in case
-    # MARIADB_EXTRA_FLAGS was not honoured by the container image.
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot \
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "SET GLOBAL character_set_server = 'utf8mb4'"
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "SET GLOBAL collation_server = 'utf8mb4_unicode_ci'"
+
+    # Throwaway-DB durability tuning at runtime. (innodb_doublewrite is read-only on MariaDB
+    # 10.6, so it can't be disabled here — would need a server startup flag.)
+    mariadb --host "$db_host" --port 3306 -u root -proot \
         -e "SET GLOBAL innodb_flush_log_at_trx_commit=0; SET GLOBAL sync_binlog=0;"
 
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE USER 'test_frappe'@'localhost' IDENTIFIED BY 'test_frappe'"
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE DATABASE test_frappe"
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "GRANT ALL PRIVILEGES ON \`test_frappe\`.* TO 'test_frappe'@'localhost'"
+    # Opt-in DDL speedup: a shared tablespace avoids a create+fsync per DocType table during
+    # reinstall — a big win under disk contention. But ROW_FORMAT=DYNAMIC must be accepted in
+    # the system tablespace on this MariaDB. Enable with CI_INNODB_SHARED_TABLESPACE=1; if
+    # reinstall then errors on table creation, unset it (off by default — zero risk).
+    if [ "${CI_INNODB_SHARED_TABLESPACE:-0}" = "1" ]; then
+        mariadb --host "$db_host" --port 3306 -u root -proot -e "SET GLOBAL innodb_file_per_table=0;"
+    fi
 
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "FLUSH PRIVILEGES"
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "CREATE USER 'test_frappe'@'${db_user_host}' IDENTIFIED BY 'test_frappe'"
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "CREATE DATABASE test_frappe"
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "GRANT ALL PRIVILEGES ON \`test_frappe\`.* TO 'test_frappe'@'${db_user_host}'"
+
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "FLUSH PRIVILEGES"
 fi
 
 if [ "$DB" == "postgres" ];then
     echo "travis" | psql -h 127.0.0.1 -p 5432 -c "CREATE DATABASE test_frappe" -U postgres;
     echo "travis" | psql -h 127.0.0.1 -p 5432 -c "CREATE USER test_frappe WITH PASSWORD 'test_frappe'" -U postgres;
+
+    # Disposable CI DB: durability off for speed (postgres fsyncs every commit by default, which
+    # dominates a commit-heavy suite). All reloadable, no restart. The postgres workflow runs a
+    # service-container DB and never calls start-db.sh, so the flags must be applied here.
+    echo "travis" | psql -h 127.0.0.1 -p 5432 -U postgres \
+        -c "ALTER SYSTEM SET synchronous_commit = 'off'" \
+        -c "ALTER SYSTEM SET fsync = 'off'" \
+        -c "ALTER SYSTEM SET full_page_writes = 'off'" \
+        -c "SELECT pg_reload_conf()";
 fi
 
-
-install_whktml() {
-    # Re-use the .deb if the wkhtmltopdf cache step already restored it.
-    if [ ! -f /tmp/wkhtmltox.deb ]; then
-        wget -O /tmp/wkhtmltox.deb https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
-    fi
-    sudo apt install /tmp/wkhtmltox.deb
-}
-install_whktml &
-wkpid=$!
-
-
 cd ~/frappe-bench || exit
 
-sed -i 's/watch:/# watch:/g' Procfile
-sed -i 's/schedule:/# schedule:/g' Procfile
-sed -i 's/socketio:/# socketio:/g' Procfile
-sed -i 's/redis_socketio:/# redis_socketio:/g' Procfile
+run_ci_step "Get payments app" bench get-app payments --branch develop
 
-bench get-app payments --branch develop
-bench get-app erpnext "${GITHUB_WORKSPACE}"
+# Opt-in: skip building erpnext's frontend assets. Server tests don't need them, but PDF
+# tests (print formats) do — they pass only if the PDF renderer ignores missing assets.
+# Enable with CI_SKIP_ERPNEXT_ASSETS=1 to test; if PDF tests fail, unset it.
+erpnext_get_app_args=()
+if [ "${CI_SKIP_ERPNEXT_ASSETS:-0}" = "1" ]; then erpnext_get_app_args=(--skip-assets); fi
+run_ci_step "Get erpnext app" bench get-app erpnext "${GITHUB_WORKSPACE}" "${erpnext_get_app_args[@]}"
 
-if [ "$TYPE" == "server" ]; then bench setup requirements --dev; fi
+if [ "$TYPE" == "server" ]; then run_ci_step "Setup dev requirements" bench setup requirements --dev; fi
 
-wait $wkpid
+bench start >> ~/frappe-bench/bench_start.log 2>&1 &
 
-bench start &>> ~/frappe-bench/bench_start.log &
-CI=Yes bench build --app frappe &
-bench --site test_site reinstall --yes
+# Under heavy concurrency, gunicorn's startup can delay redis coming up. reinstall and the
+# tests need redis, so wait for it (best-effort, bounded) instead of racing — contention
+# then slows the job rather than failing it.
+wait_for_redis() {
+    local cfg=~/frappe-bench/sites/common_site_config.json
+    [ -f "$cfg" ] || return 0
+    local ports port
+    ports=$(python - "$cfg" <<'PY'
+import json, re, sys
+try:
+    cfg = json.load(open(sys.argv[1]))
+except Exception:
+    sys.exit(0)
+for key in ("redis_cache", "redis_queue"):
+    match = re.search(r":(\d+)", str(cfg.get(key, "")))
+    if match:
+        print(match.group(1))
+PY
+)
+    for port in $ports; do
+        local up=0
+        for _ in $(seq 1 120); do
+            if (exec 3<>"/dev/tcp/127.0.0.1/$port") 2>/dev/null; then
+                exec 3>&- 3<&-; up=1
+                break
+            fi
+            sleep 1
+        done
+        # Fail clearly instead of letting reinstall die later on a vague socket-connection error
+        # when redis never bound.
+        [ "$up" = "1" ] || { echo "redis did not come up on port $port"; return 1; }
+    done
+}
+wait_for_redis
+
+# Site setup: build the schema (~1000 DocTypes) into the DB. This is the single-threaded-Python
+# bottleneck, but the fan-out amortises it — it runs once here in the setup job, and the test
+# shards start the DB on the baked datadir instead of repeating the reinstall.
+run_ci_step "Reinstall test site" bench --site test_site reinstall --yes

.github/helper/start-db.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+#
+# Run MariaDB INSIDE the runner container, on a datadir we control. Because the datadir can be
+# packaged into the bench artifact, test shards start an already-loaded server instead of
+# replaying a SQL dump (the ~60s hydrate restore). Each shard gets its own copy → isolation kept.
+#
+# CI_DB_DATADIR picks the path:
+#   - setup job:  /home/ci/db-data  (OUTSIDE the bench, so install.sh's `rm -rf ~/frappe-bench`
+#                 doesn't wipe it; it's moved into the bench just before packaging)
+#   - test shard: ~/frappe-bench/mariadb-data  (where the artifact untar'd it)
+#
+# Idempotent: inits a fresh datadir if absent (setup), else starts on the existing one (shards).
+#
+set -e
+
+ci_user="${ERPNEXT_CI_USER:-frappe}"
+
+# Re-exec as the ci user so mariadbd and the datadir are owned consistently (root mariadbd is
+# refused anyway). Mirrors install.sh's user switch.
+if [ "$(id -u)" = "0" ] && [ "${SKIP_SYSTEM_SETUP:-0}" = "1" ] && [ "$ci_user" != "root" ]; then
+    exec su -m "$ci_user" -s /bin/bash -c \
+        "ERPNEXT_CI_USER='$ci_user' CI_DB_DATADIR='${CI_DB_DATADIR:-}' DB='${DB:-}' bash '$0'"
+fi
+
+# --- PostgreSQL (GitHub-hosted CI): run in-runner on a PGDATA so it bakes into the artifact,
+# same idea as the mariadb datadir. Trust auth (throwaway CI) skips password setup; durability
+# off for speed. Postgres is preinstalled on ubuntu-latest under /usr/lib/postgresql/<ver>/bin.
+if [ "${DB:-mariadb}" = "postgres" ]; then
+    PG_BIN=$(ls -d /usr/lib/postgresql/*/bin 2>/dev/null | sort -V | tail -1)
+    [ -n "$PG_BIN" ] && export PATH="$PG_BIN:$PATH"
+    PGDATA="${CI_DB_DATADIR:-$HOME/frappe-bench/pgdata}"
+    if [ ! -d "$PGDATA/base" ]; then
+        initdb -D "$PGDATA" -U postgres --auth-local=trust --auth-host=trust >/dev/null
+        echo "host all all 127.0.0.1/32 trust" >> "$PGDATA/pg_hba.conf"
+    fi
+    pg_ctl -D "$PGDATA" -w -o "-p 5432 -c listen_addresses=127.0.0.1 -c unix_socket_directories=$PGDATA -c fsync=off -c synchronous_commit=off -c full_page_writes=off" start
+    echo "PostgreSQL up in-runner (pgdata=$PGDATA)"
+    exit 0
+fi
+
+# --- MariaDB ---
+DATADIR="${CI_DB_DATADIR:-$HOME/frappe-bench/mariadb-data}"
+SOCK="$DATADIR/mysqld.sock"
+fresh=0
+
+if [ ! -d "$DATADIR/mysql" ]; then
+    mkdir -p "$DATADIR"
+    mariadb-install-db --no-defaults --datadir="$DATADIR" \
+        --auth-root-authentication-method=normal --skip-test-db >/dev/null 2>&1
+    fresh=1
+fi
+
+# Throwaway-CI durability off; bind TCP 127.0.0.1:3306 so bench/install.sh connect as usual.
+mariadbd --no-defaults --datadir="$DATADIR" --socket="$SOCK" --pid-file="$DATADIR/mysqld.pid" \
+    --port=3306 --bind-address=127.0.0.1 \
+    --innodb-flush-log-at-trx-commit=0 --sync-binlog=0 --skip-log-bin \
+    > "$HOME/mariadb.log" 2>&1 &
+
+up=0
+for _ in $(seq 1 60); do
+    if mariadb-admin --socket="$SOCK" ping --silent 2>/dev/null; then up=1; break; fi
+    sleep 1
+done
+# Fail loudly instead of letting the loop fall through (exit 0 of the last `sleep`) into SQL that
+# would error with a vague socket-connection failure.
+[ "$up" = "1" ] || { echo "mariadbd did not come up on $SOCK"; cat "$HOME/mariadb.log" 2>/dev/null; exit 1; }
+
+if [ "$fresh" = "1" ]; then
+    # A fresh datadir has only a password-less root@localhost. Give it the password install.sh
+    # uses, plus a TCP-reachable root@127.0.0.1, so the rest of install.sh works unchanged.
+    mariadb --no-defaults --socket="$SOCK" -u root <<'SQL'
+ALTER USER 'root'@'localhost' IDENTIFIED BY 'root';
+CREATE USER IF NOT EXISTS 'root'@'127.0.0.1' IDENTIFIED BY 'root';
+GRANT ALL PRIVILEGES ON *.* TO 'root'@'127.0.0.1' WITH GRANT OPTION;
+FLUSH PRIVILEGES;
+SQL
+fi
+
+echo "MariaDB up in-container (datadir=$DATADIR, fresh=$fresh)"

.github/workflows/linters.yml

@@ -21,7 +21,7 @@ jobs:
           cache: pip
 
       - name: Install and Run Pre-commit
-        uses: pre-commit/action@v3.0.0
+        uses: pre-commit/action@v3.0.1
 
   semgrep:
     name: semgrep

.github/workflows/review-translation-changes.yaml

@@ -22,4 +22,4 @@ jobs:
       pull-requests: write
 
     steps:
-      - uses: alyf-de/po-review-action@v1.0.0
+      - uses: alyf-de/po-review-action@v1.1.0

.github/workflows/server-tests-mariadb.yml

@@ -31,51 +31,49 @@ on:
 
 permissions:
   contents: read
+  packages: read
 
 concurrency:
   group: server-mariadb-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
   cancel-in-progress: true
 
+# Shared across both jobs. Both run in the SAME CI image so the bench lives at the identical
+# path (/home/ci/frappe-bench) on the setup runner and the test shards — that's what makes the
+# packaged Python venv portable between them.
+env:
+  TZ: 'Asia/Kolkata'
+  DEBIAN_FRONTEND: noninteractive
+  NODE_ENV: "production"
+  WITH_COVERAGE: ${{ github.event_name != 'pull_request' }}
+  ERPNEXT_CI_USER: ci
+  PIP_CACHE_DIR: /home/ci/.cache/pip
+  npm_config_cache: /home/ci/.cache/npm
+  YARN_CACHE_FOLDER: /home/ci/.cache/yarn
+  UV_CACHE_DIR: /home/ci/.cache/uv
+
 jobs:
-  test:
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    env:
-      TZ: 'Asia/Kolkata'
-      NODE_ENV: "production"
-      WITH_COVERAGE: ${{ github.event_name != 'pull_request' }}
-
-    strategy:
-      fail-fast: false
-
-      matrix:
-        container: [1, 2, 3, 4]
-
-    name: Python Unit Tests
-
-    services:
-      mysql:
-        image: mariadb:10.6
-        env:
-          TZ: 'Asia/Kolkata'
-          MARIADB_ROOT_PASSWORD: 'root'
-          # Disable durability guarantees that are unnecessary in a throwaway CI container.
-          # innodb_flush_log_at_trx_commit=0 avoids an fsync on every commit (biggest win).
-          # sync_binlog=0 skips binary-log syncs; innodb_doublewrite=0 skips the doublewrite buffer.
-          MARIADB_EXTRA_FLAGS: --innodb-flush-log-at-trx-commit=0 --sync-binlog=0 --innodb-doublewrite=0
-        ports:
-          - 3306:3306
-        options: --health-cmd="mariadb-admin ping" --health-interval=5s --health-timeout=2s --health-retries=3
-
+  # Build the bench (clone + pip + yarn + assets) and reinstall test_site ONCE, on a free
+  # GitHub-hosted runner, then publish the whole bench (with a DB dump baked in) as an artifact.
+  # The expensive, non-parallelisable work happens here exactly once instead of on every shard.
+  setup:
+    name: Build & reinstall (setup)
+    # Dedicated scale set (fat cpu request) so the build+reinstall runs at full speed, uncontended
+    # by the many thin test shards. Same CI image + /home/ci path + 127.0.0.1 DB as the shards,
+    # so the packaged bench (and its venv) transplants cleanly.
+    runs-on: erpnext-arc-setup
+    timeout-minutes: 40
+    container:
+      image: ghcr.io/frappe/erpnext-ci-mariadb:py3.14-node24
+      credentials:
+        username: ${{ secrets.GHCR_USERNAME || github.actor }}
+        password: ${{ secrets.GHCR_TOKEN || github.token }}
+    defaults:
+      run:
+        shell: bash
     steps:
       - name: Clone
         uses: actions/checkout@v6
 
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: '3.14'
-
       - name: Check for valid Python & Merge Conflicts
         run: |
           python -m compileall -fq "${GITHUB_WORKSPACE}"
@@ -84,53 +82,17 @@ jobs:
               exit 1
           fi
 
-      - name: Setup Node
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          check-latest: true
-
       - name: Add to Hosts
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
-      - name: Cache pip
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
-          restore-keys: |
-            ${{ runner.os }}-pip-
-            ${{ runner.os }}-
-
-      - name: Cache node modules
-        uses: actions/cache@v4
+      # MariaDB runs in-container on a datadir OUTSIDE the bench, because install.sh's next step
+      # does `rm -rf ~/frappe-bench`. After the reinstall, the datadir is moved into the bench so
+      # it ships in the artifact — test shards then start an already-loaded server (no restore).
+      - name: Start DB
+        run: bash ${GITHUB_WORKSPACE}/.github/helper/start-db.sh
         env:
-          cache-name: cache-node-modules
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
-
-      - name: Get yarn cache directory path
-        id: yarn-cache-dir-path
-        run: echo "dir=$(yarn cache dir)" >> $GITHUB_OUTPUT
-
-      - uses: actions/cache@v4
-        id: yarn-cache
-        with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
-
-      - name: Cache wkhtmltopdf
-        uses: actions/cache@v4
-        with:
-          path: /tmp/wkhtmltox.deb
-          key: wkhtmltox-0.12.6.1-2-jammy-amd64
+          SKIP_SYSTEM_SETUP: "1"
+          CI_DB_DATADIR: /home/ci/db-data
 
       - name: Install
         run: bash ${GITHUB_WORKSPACE}/.github/helper/install.sh
@@ -139,9 +101,88 @@ jobs:
           TYPE: server
           FRAPPE_USER: ${{ github.event.inputs.user }}
           FRAPPE_BRANCH: ${{ github.event.client_payload.sha || github.event.inputs.branch }}
+          DB_HOST: 127.0.0.1
+          DB_USER_HOST: '%'
+          WKHTMLTOX_DEB: /tmp/wkhtmltox.deb
+          SKIP_SYSTEM_SETUP: "1"
+          SKIP_WKHTMLTOX_SETUP: "1"
+
+      - name: Warm up test data
+        run: |
+          su -m "${ERPNEXT_CI_USER:-frappe}" -s /bin/bash <<'EOF'
+          cd ~/frappe-bench/
+          bench --site test_site run-tests --lightmode --module erpnext.tests.bootstrap_test_data
+          EOF
+
+      # Clean shutdown (consistent InnoDB datadir), then stage it inside the bench for packaging.
+      - name: Stop DB and stage datadir
+        run: |
+          mariadb-admin -h 127.0.0.1 -P 3306 -u root -proot shutdown || true
+          for _ in $(seq 1 30); do [ -f /home/ci/db-data/mysqld.pid ] || break; sleep 1; done
+          # Don't bake a dirty datadir — fail if mariadbd didn't finish stopping, rather than ship
+          # an inconsistent datadir the shards would have to crash-recover.
+          [ -f /home/ci/db-data/mysqld.pid ] && { echo "mariadbd did not shut down cleanly"; exit 1; }
+          mv /home/ci/db-data /home/ci/frappe-bench/mariadb-data
+
+      # Package the whole bench (apps, venv, node_modules, sites, the DB dump, and hydrate.sh)
+      # into one artifact for the test shards to consume.
+      # Single-node hand-off: stage the bench on a node-local hostPath instead of round-tripping
+      # through GitHub artifact storage (~60s/shard). Setup and shards share the same disk, so
+      # the shards just untar it locally. NOTE: this assumes one node — a shard on a different
+      # node could not read this path (then you'd need GitHub artifacts or an NFS/RWX volume).
+      - name: Stage bench on node (hostPath)
+        run: |
+          cp "${GITHUB_WORKSPACE}/.github/helper/hydrate.sh" /home/ci/frappe-bench/hydrate.sh
+          cp "${GITHUB_WORKSPACE}/.github/helper/start-db.sh" /home/ci/frappe-bench/start-db.sh
+          mkdir -p /opt/ci-bench-staging
+          # self-clean: drop bench tars from runs older than 2h
+          find /opt/ci-bench-staging -maxdepth 1 -name '*.tar.gz' -mmin +120 -delete 2>/dev/null || true
+          # Exclude .git/node_modules; the mariadb-data datadir IS included (the pre-loaded DB).
+          tar czpf "/opt/ci-bench-staging/${GITHUB_RUN_ID}.tar.gz" -C /home/ci \
+            --exclude='.git' --exclude='node_modules' frappe-bench
+          ls -lh "/opt/ci-bench-staging/${GITHUB_RUN_ID}.tar.gz"
+
+  # Fan-out: each shard downloads the bench, untars it, starts MariaDB on the baked datadir, and
+  # runs its slice of the suite. No clone, no build, no reinstall, no DB dump restore on the shards.
+  test:
+    name: Python Unit Tests
+    needs: setup
+    runs-on: erpnext-arc
+    timeout-minutes: 60
+    container:
+      image: ghcr.io/frappe/erpnext-ci-mariadb:py3.14-node24
+      credentials:
+        username: ${{ secrets.GHCR_USERNAME || github.actor }}
+        password: ${{ secrets.GHCR_TOKEN || github.token }}
+    defaults:
+      run:
+        shell: bash
+
+    strategy:
+      fail-fast: false
+      matrix:
+        container: [1, 2, 3, 4]
+
+    steps:
+      - name: Add to Hosts
+        run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
+
+      # Read the bench straight from the node-local hostPath the setup job staged it on — no
+      # GitHub download. -p preserves the ci (uid 1001) ownership so bench runs as ci cleanly.
+      - name: Untar bench from node (hostPath)
+        run: |
+          tar xzpf "/opt/ci-bench-staging/${GITHUB_RUN_ID}.tar.gz" -C /home/ci
+          ls -ld /home/ci/frappe-bench
+
+      - name: Hydrate (start DB on baked datadir + bench start)
+        run: bash /home/ci/frappe-bench/hydrate.sh
+        env:
+          DB_HOST: 127.0.0.1
+          SKIP_SYSTEM_SETUP: "1"
 
       - name: Run Tests
         run: |
+          su -m "${ERPNEXT_CI_USER:-frappe}" -s /bin/bash <<'EOF'
           cd ~/frappe-bench/
           coverage_flag=""
           if [ "$WITH_COVERAGE" = "true" ]; then coverage_flag="--with-coverage"; fi
@@ -149,10 +190,10 @@ jobs:
             --total-builds ${{ strategy.job-total }} \
             --build-number ${{ matrix.container }} \
             $coverage_flag
+          EOF
         env:
           TYPE: server
 
-
       - name: Show bench output
         if: ${{ always() }}
         run: cat ~/frappe-bench/bench_start.log || true
@@ -162,11 +203,11 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: coverage-${{ matrix.container }}
-          path: /home/runner/frappe-bench/sites/coverage.xml
+          path: /home/ci/frappe-bench/sites/coverage.xml
 
   coverage:
     name: Coverage Wrap Up
-    needs: test
+    needs: [test]
     if: ${{ github.event_name != 'pull_request' }}
     runs-on: ubuntu-latest
     steps:

.pre-commit-config.yaml

@@ -48,7 +48,6 @@ repos:
                 cypress/.*|
                 .*node_modules.*|
                 .*boilerplate.*|
-                erpnext/public/js/controllers/.*|
                 erpnext/templates/pages/order.js|
                 erpnext/templates/includes/.*
             )$

banking/package.json

@@ -14,35 +14,35 @@
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
-    "@tailwindcss/vite": "^4.3.0",
+    "@tailwindcss/vite": "^4.3.2",
     "@tanstack/react-table": "^8.21.3",
     "@tanstack/react-virtual": "^3.13.24",
-    "@vitejs/plugin-react": "^6.0.1",
+    "@vitejs/plugin-react": "^6.0.3",
     "chrono-node": "^2.9.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "dayjs": "^1.11.20",
-    "frappe-react-sdk": "^1.15.0",
+    "frappe-react-sdk": "^1.17.0",
     "fuse.js": "^7.3.0",
-    "jotai": "^2.20.0",
-    "jotai-family": "^1.0.1",
+    "jotai": "^2.20.1",
+    "jotai-family": "^1.0.2",
     "lodash.isplainobject": "^4.0.6",
     "lucide-react": "^1.14.0",
-    "radix-ui": "^1.4.3",
-    "react": "^19.2.6",
+    "radix-ui": "^1.6.1",
+    "react": "^19.2.7",
     "react-currency-input-field": "^4.0.5",
     "react-day-picker": "9.14.0",
-    "react-dom": "^19.2.6",
+    "react-dom": "^19.2.7",
     "react-dropzone": "^15.0.0",
     "react-hook-form": "^7.75.0",
     "react-hotkeys-hook": "^5.3.2",
     "react-markdown": "^10.1.0",
-    "react-router": "^7.15.0",
-    "react-router-dom": "^7.15.0",
+    "react-router": "^8.1.0",
     "rehype-raw": "^7.0.0",
     "remark-gfm": "^4.0.1",
+    "safe-expr-eval": "^1.0.4",
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "^4.3.0",
@@ -51,15 +51,15 @@
     "vite": "^8.0.16"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.1",
+    "@eslint/js": "^9.39.4",
     "@types/node": "^25.3.0",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "eslint": "^9.39.1",
     "eslint-plugin-react-hooks": "^7.1.1",
-    "eslint-plugin-react-refresh": "^0.4.24",
+    "eslint-plugin-react-refresh": "^0.5.3",
     "globals": "^16.5.0",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.48.0"
+    "typescript-eslint": "^8.62.1"
   }
 }

banking/src/App.tsx

@@ -1,5 +1,5 @@
 import { lazy, useEffect } from 'react'
-import { BrowserRouter, Navigate, Route, Routes } from 'react-router-dom'
+import { BrowserRouter, Navigate, Route, Routes } from 'react-router'
 import { FrappeProvider } from 'frappe-react-sdk'
 import { Toaster } from '@/components/ui/sonner'
 import BankReconciliation from '@/pages/BankReconciliation'

banking/src/components/features/BankReconciliation/BankClearanceSummary.tsx

@@ -2,7 +2,6 @@ import { useAtomValue } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, SelectedBank, selectedBankAccountAtom } from "./bankRecAtoms"
 import { useCurrentCompany } from "@/hooks/useCurrentCompany"
-import { Paragraph } from "@/components/ui/typography"
 import type { ColumnDef } from "@tanstack/react-table"
 import { useCallback, useMemo, useState } from "react"
 import { useFrappeGetCall, useFrappePostCall, useSWRConfig } from "frappe-react-sdk"
@@ -26,6 +25,7 @@ import { Form } from "@/components/ui/form"
 import { useForm } from "react-hook-form"
 import { DateField } from "@/components/ui/form-elements"
 import { Empty, EmptyMedia, EmptyHeader, EmptyTitle, EmptyDescription } from "@/components/ui/empty"
+import MarkdownRenderer from "@/components/ui/markdown"
 
 const BankClearanceSummary = () => {
     const bankAccount = useAtomValue(selectedBankAccountAtom)
@@ -203,14 +203,14 @@ const BankClearanceSummaryView = () => {
         [accountCurrency, bankAccount, companyID, mutate, onCopy],
     )
 
+    const content = _("Below is a list of all accounting entries posted against the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
+
     return <div className="space-y-4 py-2">
 
         <div>
-            <Paragraph className="text-sm">
-                <span dangerouslySetInnerHTML={{
-                    __html: _("Below is a list of all accounting entries posted against the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
-                }} />
-            </Paragraph>
+            <span className="text-p-sm">
+                <MarkdownRenderer content={content} />
+            </span>
         </div>
 
         {error && <ErrorBanner error={error} />}

banking/src/components/features/BankReconciliation/BankEntryModalContent.tsx

@@ -18,6 +18,7 @@ import { useMultiFileUploadProgress } from "@/hooks/useMultiFileUploadProgress"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
 import { Checkbox } from "@/components/ui/checkbox"
 import { ArrowDownRight, ArrowUpRight, Plus, Trash2 } from "lucide-react"
+import { evaluateAmountFormula } from "@/lib/amountFormula"
 import { flt, formatCurrency } from "@/lib/numbers"
 import { cn } from "@/lib/utils"
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
@@ -215,38 +216,13 @@ const BankEntryForm = ({ selectedTransaction }: { selectedTransaction: Unreconci
                         })
                     } else {
 
-                        /**
-                         * The debit and credit amounts can also be expressions - like "transaction_amount * 0.5"
-                         * So we need to compute the value of the expression
-                         * We can use the eval function to do this. But we need to expose certain variables to the expression.
-                         * One of them is transaction_amount which is the unallocated amount of the selected transaction
-                         * @param expression - The expression to compute
-                         * @returns The computed value
-                         */
-                        const computeExpression = (expression: string) => {
-
-                            const script = `
-                                const transaction_amount = ${selectedTransaction.unallocated_amount ?? 0}
-                                ${expression};
-                            `
-
-                            let value = 0;
-
-                            try {
-                                value = window.eval(script);
-                            } catch (error: unknown) {
-                                console.error(error);
-                                value = 0;
-                            }
-
-                            return value;
-                        }
+                        const transactionAmount = selectedTransaction.unallocated_amount ?? 0
                         if (!acc?.debit && !acc?.credit) {
                             hasTotallyEmptyRowEarlier = true;
                         }
 
-                        const computedDebit = acc?.debit ? flt(computeExpression(acc.debit), 2) : 0
-                        const computedCredit = acc?.credit ? flt(computeExpression(acc.credit), 2) : 0
+                        const computedDebit = acc?.debit ? flt(evaluateAmountFormula(acc.debit, transactionAmount), 2) : 0
+                        const computedCredit = acc?.credit ? flt(evaluateAmountFormula(acc.credit, transactionAmount), 2) : 0
 
                         totalDebits = flt(totalDebits + computedDebit, 2)
                         totalCredits = flt(totalCredits + computedCredit, 2)

banking/src/components/features/BankReconciliation/BankReconciliationStatement.tsx

@@ -2,7 +2,6 @@ import { useAtomValue } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, selectedBankAccountAtom } from "./bankRecAtoms"
 import { useCurrentCompany } from "@/hooks/useCurrentCompany"
-import { Paragraph } from "@/components/ui/typography"
 import { useCallback, useMemo } from "react"
 import type { ColumnDef } from "@tanstack/react-table"
 import { useFrappeGetCall } from "frappe-react-sdk"
@@ -19,6 +18,7 @@ import _ from "@/lib/translate"
 import { toast } from "sonner"
 import { useCopyToClipboard } from "usehooks-ts"
 import { Empty, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle } from "@/components/ui/empty"
+import MarkdownRenderer from "@/components/ui/markdown"
 
 const BankReconciliationStatement = () => {
     const bankAccount = useAtomValue(selectedBankAccountAtom)
@@ -189,14 +189,14 @@ const BankReconciliationStatementView = () => {
         return data.message.result.filter((row: BankClearanceSummaryEntry) => Boolean(row.payment_entry))
     }, [data])
 
+    const content = _("Below is a list of all entries posted against the bank account {0} which have not been cleared till {1}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formatDate(dates.toDate)}</strong>`])
+
     return <div className="space-y-4 py-2">
 
         <div>
-            <Paragraph className="text-sm">
-                <span dangerouslySetInnerHTML={{
-                    __html: _("Below is a list of all entries posted against the bank account {0} which have not been cleared till {1}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formatDate(dates.toDate)}</strong>`])
-                }} />
-            </Paragraph>
+            <span className="text-p-sm">
+                <MarkdownRenderer content={content} />
+            </span>
         </div>
 
         {error && <ErrorBanner error={error} />}

banking/src/components/features/BankReconciliation/BankTransactionList.tsx

@@ -1,7 +1,6 @@
 import { useAtomValue, useSetAtom } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, bankRecUnreconcileModalAtom, selectedBankAccountAtom } from "./bankRecAtoms"
-import { Paragraph } from "@/components/ui/typography"
 import { formatDate } from "@/lib/date"
 import { ListView, type ListViewColumnMeta } from "@/components/ui/list-view"
 import { formatCurrency, getCurrencyFormatInfo } from "@/lib/numbers"
@@ -23,6 +22,7 @@ import { useCallback, useMemo, useState } from "react"
 import { Link } from "react-router"
 import { Empty, EmptyTitle, EmptyHeader, EmptyMedia, EmptyDescription, EmptyContent } from "@/components/ui/empty"
 import { InputGroup, InputGroupAddon } from "@/components/ui/input-group"
+import MarkdownRenderer from "@/components/ui/markdown"
 
 const BankTransactions = () => {
     const selectedBank = useAtomValue(selectedBankAccountAtom)
@@ -243,14 +243,14 @@ const BankTransactionListView = () => {
 
     }, [data, search, amountFilter, typeFilter, status])
 
+    const content = _("Below is a list of all bank transactions imported in the system for the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account_name}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
+
     return <div className="space-y-2 py-2">
 
         <div className="flex gap-2 justify-between items-center">
-            <Paragraph className="text-sm">
-                <span dangerouslySetInnerHTML={{
-                    __html: _("Below is a list of all bank transactions imported in the system for the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account_name}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
-                }} />
-            </Paragraph>
+            <span className="text-p-sm">
+                <MarkdownRenderer content={content} />
+            </span>
 
             <Button size='md' variant='subtle' asChild>
                 <Link to="/statement-importer">

banking/src/components/features/BankReconciliation/IncorrectlyClearedEntries.tsx

@@ -2,7 +2,6 @@ import { useAtomValue } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, selectedBankAccountAtom } from "./bankRecAtoms"
 import { useCurrentCompany } from "@/hooks/useCurrentCompany"
-import { Paragraph } from "@/components/ui/typography"
 import type { ColumnDef } from "@tanstack/react-table"
 import { useCallback, useMemo } from "react"
 import { useFrappeGetCall, useFrappePostCall } from "frappe-react-sdk"
@@ -18,6 +17,7 @@ import { PartyPopper } from "lucide-react"
 import ErrorBanner from "@/components/ui/error-banner"
 import _ from "@/lib/translate"
 import { Empty, EmptyTitle, EmptyDescription, EmptyMedia, EmptyHeader } from "@/components/ui/empty"
+import MarkdownRenderer from "@/components/ui/markdown"
 
 const IncorrectlyClearedEntries = () => {
     const companyID = useCurrentCompany()
@@ -177,22 +177,22 @@ const IncorrectlyClearedEntriesView = () => {
         [accountCurrency, onClearClick],
     )
 
+    const content = _("This report shows all entries in the system where the <strong>clearance date is before the posting date</strong> which is incorrect.")
+
+    const entriesContent = _("Entries below have a posting date after {0} but the clearance date is before {1}.", [`<strong>${formattedToDate}</strong>`, `<strong>${formattedToDate}</strong>`])
+
     return <div className="space-y-4 py-2">
 
         <div>
-            <Paragraph className="text-sm">
-                <span dangerouslySetInnerHTML={{
-                    __html: _("This report shows all entries in the system where the <strong>clearance date is before the posting date</strong> which is incorrect.")
-                }} />
+            <span className="text-p-sm">
+                <MarkdownRenderer content={content} />
                 <br />
                 {data && data.message.result.length > 0 && <span>
-                    <span dangerouslySetInnerHTML={{
-                        __html: _("Entries below have a posting date after {0} but the clearance date is before {1}.", [`<strong>${formattedToDate}</strong>`, `<strong>${formattedToDate}</strong>`])
-                    }} />
+                    <MarkdownRenderer content={entriesContent} />
                     <br />
                     {_("You can reset the clearing dates of these entries here.")}
                 </span>}
-            </Paragraph>
+            </span>
         </div>
 
         {error && <ErrorBanner error={error} />}

banking/src/components/features/BankReconciliation/Rules/RuleForm.tsx

@@ -11,6 +11,7 @@ import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
 import { H4, Paragraph } from "@/components/ui/typography"
 import { today } from "@/lib/date"
+import { evaluateAmountFormula } from "@/lib/amountFormula"
 import _ from "@/lib/translate"
 import { cn } from "@/lib/utils"
 import { BankTransactionRule } from "@/types/Accounts/BankTransactionRule"
@@ -445,11 +446,10 @@ const AmountFormulaRenderer = ({ value }: { value?: string }) => {
     // If it's a string and cannot be a number, then show it as a formula
 
     if (isNaN(Number(value))) {
-
         let calculatedValue = "";
 
         try {
-            calculatedValue = window.eval(`const transaction_amount = 200; ${value}`);
+            calculatedValue = String(evaluateAmountFormula(value ?? "", 200));
         } catch (error: unknown) {
             console.error(error);
             calculatedValue = "Error";

banking/src/components/features/BankStatementImporter/CSV/StatementDetails.tsx

@@ -14,7 +14,7 @@ import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip
 import { useFrappeEventListener, useFrappePostCall } from 'frappe-react-sdk'
 import { toast } from 'sonner'
 import ErrorBanner from '@/components/ui/error-banner'
-import { Link, useNavigate } from 'react-router-dom'
+import { Link, useNavigate } from 'react-router'
 import { useMemo, useState } from 'react'
 import { Progress } from '@/components/ui/progress'
 import { useSetAtom } from 'jotai'

banking/src/lib/amountFormula.ts

@@ -0,0 +1,26 @@
+import { Parser } from 'safe-expr-eval'
+
+const parser = new Parser()
+
+const PLAIN_NUMBER_PATTERN = /^-?\d+(\.\d+)?$/
+
+export function evaluateAmountFormula(expression: string, transactionAmount: number): number {
+    const trimmed = expression.trim()
+    if (!trimmed) {
+        return 0
+    }
+
+    if (PLAIN_NUMBER_PATTERN.test(trimmed)) {
+        return Number(trimmed)
+    }
+
+    try {
+        const result = parser.parse(trimmed).evaluate({ transaction_amount: transactionAmount })
+        if (typeof result !== 'number' || !Number.isFinite(result)) {
+            return 0
+        }
+        return result
+    } catch {
+        return 0
+    }
+}

erpnext/__init__.py

@@ -6,7 +6,7 @@ import frappe
 from frappe.model.document import Document
 from frappe.utils.user import is_website_user
 
-__version__ = "16.25.0"
+__version__ = "16.28.0"
 
 
 def get_default_company(user=None):

erpnext/accounts/doctype/account/chart_of_accounts/verified/philippines.json

@@ -22,12 +22,12 @@
 						"account_type": "Cash"
 					},
 					"Petty Cash Fund": {
-						"account_number": "1200",
+						"account_number": "1110",
 						"is_group": 1,
 						"root_type": "Asset",
 						"account_type": "Cash",
 						"Petty Cash Fund": {
-							"account_number": "1201",
+							"account_number": "1111",
 							"is_group": 0,
 							"root_type": "Asset",
 							"account_type": "Cash"
@@ -35,10 +35,16 @@
 					}
 				},
 				"Bank Accounts": {
-					"account_number": "1102",
+					"account_number": "1200",
 					"is_group": 1,
 					"root_type": "Asset",
-					"account_type": "Bank"
+					"account_type": "Bank",
+					"Cash in Bank - Checking Account": {
+						"account_number": "1201",
+						"is_group": 0,
+						"root_type": "Asset",
+						"account_type": "Bank"
+					}
 				},
 				"Advances to Officers & Employees": {
 					"account_number": "1290",
@@ -104,25 +110,20 @@
 						"account_number": "1511",
 						"is_group": 0,
 						"root_type": "Asset"
-					},
-					"Factory Overhead Variance": {
-						"account_number": "1512",
-						"is_group": 0,
-						"root_type": "Asset"
 					}
 				},
 				"Finished Goods": {
-					"account_number": "1520",
+					"account_number": "1540",
 					"is_group": 1,
 					"root_type": "Asset",
 					"Finished Goods Inventory": {
-						"account_number": "1531",
+						"account_number": "1541",
 						"is_group": 0,
 						"root_type": "Asset",
 						"account_type": "Stock"
 					},
 					"Inventory in Transit": {
-						"account_number": "1532",
+						"account_number": "1542",
 						"is_group": 0,
 						"root_type": "Asset",
 						"account_type": "Stock Adjustment"
@@ -268,7 +269,7 @@
 						"root_type": "Asset"
 					}
 				},
-				"System Development": {
+				"Intangible Assets": {
 					"account_number": "1940",
 					"is_group": 1,
 					"root_type": "Asset",
@@ -277,6 +278,17 @@
 						"is_group": 0,
 						"root_type": "Asset"
 					}
+				},
+				"Accumulated Amortization - Intangible Assets": {
+					"account_number": "1950",
+					"is_group": 1,
+					"root_type": "Asset",
+					"Accum Amortization - System Development": {
+						"account_number": "1951",
+						"is_group": 0,
+						"root_type": "Asset",
+						"account_type": "Accumulated Depreciation"
+					}
 				}
 			}
 		},
@@ -406,8 +418,7 @@
 				"Customer Deposits": {
 					"account_number": "2500",
 					"is_group": 0,
-					"root_type": "Liability",
-					"account_type": "Payable"
+					"root_type": "Liability"
 				}
 			},
 			"Non Current Liabilities": {
@@ -563,6 +574,28 @@
 						"is_group": 0,
 						"root_type": "Income"
 					}
+				},
+				"Exchange Gain": {
+					"account_number": "6030",
+					"is_group": 1,
+					"root_type": "Income",
+					"Exchange Gain - Detail": {
+						"account_number": "6031",
+						"is_group": 0,
+						"root_type": "Income",
+						"account_type": "Indirect Income"
+					}
+				},
+				"Gain on Asset Disposal": {
+					"account_number": "6040",
+					"is_group": 1,
+					"root_type": "Income",
+					"Gain on Asset Disposal - Detail": {
+						"account_number": "6041",
+						"is_group": 0,
+						"root_type": "Income",
+						"account_type": "Indirect Income"
+					}
 				}
 			}
 		},
@@ -575,7 +608,7 @@
 				"is_group": 1,
 				"root_type": "Expense",
 				"Cost of Goods Sold": {
-					"account_number": "5010",
+					"account_number": "5002",
 					"is_group": 0,
 					"root_type": "Expense",
 					"account_type": "Cost of Goods Sold"
@@ -828,20 +861,61 @@
 					"root_type": "Expense"
 				}
 			},
-			"Stock Adjustment": {
+			"Other Expenses": {
 				"account_number": "5200",
+				"is_group": 1,
+				"root_type": "Expense",
+				"Bank Charges": {
+					"account_number": "5201",
+					"is_group": 0,
+					"root_type": "Expense",
+					"account_type": "Indirect Expense"
+				},
+				"Interest Expenses Bank": {
+					"account_number": "5202",
+					"is_group": 0,
+					"root_type": "Expense",
+					"account_type": "Indirect Expense"
+				},
+				"Write Off": {
+					"account_number": "5203",
+					"is_group": 0,
+					"root_type": "Expense",
+					"account_type": "Indirect Expense"
+				},
+				"Exchange Loss": {
+					"account_number": "5204",
+					"is_group": 0,
+					"root_type": "Expense",
+					"account_type": "Indirect Expense"
+				},
+				"Loss on Asset Disposal": {
+					"account_number": "5205",
+					"is_group": 0,
+					"root_type": "Expense",
+					"account_type": "Indirect Expense"
+				}
+			},
+			"Provision For Income Tax": {
+				"account_number": "5300",
+				"is_group": 0,
+				"root_type": "Expense",
+				"account_type": "Tax"
+			},
+			"Stock Adjustment": {
+				"account_number": "5400",
 				"is_group": 0,
 				"root_type": "Expense",
 				"account_type": "Stock Adjustment"
 			},
 			"Round Off": {
-				"account_number": "5300",
+				"account_number": "5500",
 				"is_group": 0,
 				"root_type": "Expense",
 				"account_type": "Round Off"
 			},
 			"Expenses Included In Valuation": {
-				"account_number": "5400",
+				"account_number": "5600",
 				"is_group": 0,
 				"root_type": "Expense",
 				"account_type": "Expenses Included In Valuation"

erpnext/accounts/doctype/accounting_period/accounting_period.py

@@ -5,6 +5,7 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
+from frappe.utils import getdate, nowdate
 
 
 class OverlapError(frappe.ValidationError):
@@ -36,8 +37,20 @@ class AccountingPeriod(Document):
 	# end: auto-generated types
 
 	def validate(self):
+		self.validate_dates()
 		self.validate_overlap()
 
+	def validate_dates(self):
+		if getdate(self.start_date) > getdate(self.end_date):
+			frappe.throw(_("Start Date cannot be after End Date"))
+
+		if getdate(self.end_date) > getdate(nowdate()):
+			frappe.throw(
+				_(
+					"Accounting Period cannot be created for a future date. End Date {0} is after today."
+				).format(frappe.bold(frappe.format(self.end_date, "Date")))
+			)
+
 	def before_insert(self):
 		self.bootstrap_doctypes_for_closing()
 

erpnext/accounts/doctype/accounting_period/test_accounting_period.py

@@ -3,7 +3,7 @@
 import unittest
 
 import frappe
-from frappe.utils import add_months, nowdate
+from frappe.utils import nowdate
 
 from erpnext.accounts.doctype.accounting_period.accounting_period import (
 	ClosedAccountingPeriod,
@@ -94,7 +94,7 @@ def create_accounting_period(**args):
 
 	accounting_period = frappe.new_doc("Accounting Period")
 	accounting_period.start_date = args.start_date or nowdate()
-	accounting_period.end_date = args.end_date or add_months(nowdate(), 1)
+	accounting_period.end_date = args.end_date or nowdate()
 	accounting_period.company = args.company or "_Test Company"
 	accounting_period.period_name = args.period_name or "_Test_Period_Name_1"
 	accounting_period.append("closed_documents", {"document_type": "Sales Invoice", "closed": 1})

erpnext/accounts/doctype/bank_account/bank_account.py

@@ -107,7 +107,7 @@ def get_party_bank_account(party_type, party):
 	)
 
 
-def get_default_company_bank_account(company, party_type, party):
+def get_default_company_bank_account(company, party_type, party, ignore_permissions=True):
 	default_company_bank_account = frappe.db.get_value(party_type, party, "default_bank_account")
 	if default_company_bank_account:
 		if company != frappe.get_cached_value("Bank Account", default_company_bank_account, "company"):
@@ -118,6 +118,14 @@ def get_default_company_bank_account(company, party_type, party):
 			"Bank Account", {"company": company, "is_company_account": 1, "is_default": 1}
 		)
 
+	if not ignore_permissions:
+		default_company_bank_account = (
+			default_company_bank_account
+			if default_company_bank_account
+			and frappe.get_cached_doc("Bank Account", default_company_bank_account).has_permission("select")
+			else None
+		)
+
 	return default_company_bank_account
 
 

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -64,7 +64,7 @@ def get_bank_transactions(
 		filters.append(["date", "<=", to_date])
 	if from_date:
 		filters.append(["date", ">=", from_date])
-	transactions = frappe.get_all(
+	transactions = frappe.get_list(
 		"Bank Transaction",
 		fields=[
 			"date",
@@ -93,6 +93,7 @@ def get_bank_transactions(
 @frappe.whitelist()
 def get_account_balance(bank_account: str, till_date: str | date, company: str):
 	# returns account balance till the specified date
+	frappe.has_permission("Bank Account", "read", bank_account, throw=True)
 	account = frappe.db.get_value("Bank Account", bank_account, "account")
 	filters = frappe._dict(
 		{

erpnext/accounts/doctype/bank_statement_import_log/bank_statement_import_log.json

@@ -54,7 +54,6 @@
    "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Closing Balance",
-   "non_negative": 1,
    "options": "currency"
   },
   {
@@ -191,7 +190,7 @@
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2026-05-08 17:55:25.615942",
+ "modified": "2026-07-09 17:55:25.615942",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Statement Import Log",

erpnext/accounts/doctype/bank_statement_import_log/bank_statement_import_log.py

@@ -557,7 +557,7 @@ class BankStatementImportLog(Document):
 			docname=self.name,
 		)
 
-		if self.closing_balance and self.closing_balance > 0 and self.end_date:
+		if self.closing_balance is not None and self.end_date:
 			set_closing_balance_as_per_statement(
 				self.bank_account, frappe.utils.getdate(self.end_date), self.closing_balance
 			)
@@ -829,7 +829,9 @@ def compute_final_transactions(transaction_rows: list, date_format: str, amount_
 
 		if amount_format == 'Amount column has "CR"/"DR" values':
 			amount = transaction_row.get("amount")
-			float_amount = get_float_amount(amount)
+
+			# If the amount column has CR/DR in it - we should remove any signs (negative or positive) from the amount
+			float_amount = abs(get_float_amount(amount) or 0)
 			if "cr" in amount.lower():
 				return 0, float_amount
 			else:
@@ -932,14 +934,18 @@ def extract_pdf_tables(content: bytes, password: str | None = None) -> list[dict
 	from pypdf import PdfReader
 
 	reader = PdfReader(io.BytesIO(content))
-	if reader.is_encrypted and (not password or not reader.decrypt(password)):
-		frappe.throw(
-			_(
-				"This PDF is password protected. Please set the correct statement password on the"
-				" Bank Account and try again."
-			),
-			title=_("Password Required"),
-		)
+	if reader.is_encrypted:
+		# Try opening the PDF with a password - if no password is provided, try with a blank password
+		if not password:
+			password = ""
+		if not reader.decrypt(password):
+			frappe.throw(
+				_(
+					"This PDF is password protected. Please set the correct statement password on the"
+					" Bank Account and try again."
+				),
+				title=_("Password Required"),
+			)
 
 	text_settings = {"vertical_strategy": "text", "horizontal_strategy": "text"}
 	tables = []

erpnext/accounts/doctype/bank_transaction/test_bank_transaction.py

@@ -104,6 +104,36 @@ class TestBankTransaction(ERPNextTestSuite):
 		self.assertEqual(bank_transaction.unallocated_amount, 1700)
 		self.assertEqual(bank_transaction.payment_entries, [])
 
+	# Amending a reconciled payment entry must not carry over its clearance date
+	def test_clearance_date_cleared_on_amend(self):
+		bank_transaction = frappe.get_doc(
+			"Bank Transaction",
+			dict(description="1512567 BG/000003025 OPSKATTUZWXXX AT776000000098709849 Herr G"),
+		)
+		payment = frappe.get_doc("Payment Entry", dict(party="Mr G", paid_amount=1700))
+		vouchers = json.dumps(
+			[
+				{
+					"payment_doctype": "Payment Entry",
+					"payment_name": payment.name,
+					"amount": bank_transaction.unallocated_amount,
+				}
+			]
+		)
+		reconcile_vouchers(bank_transaction.name, vouchers)
+
+		self.assertTrue(frappe.db.get_value("Payment Entry", payment.name, "clearance_date"))
+
+		payment.reload()
+		payment.cancel()
+
+		amended = frappe.copy_doc(payment)
+		amended.amended_from = payment.name
+		amended.docstatus = 0
+		amended.insert()
+
+		self.assertFalse(amended.clearance_date)
+
 	# Check if ERPNext can correctly filter a linked payments based on the debit/credit amount
 	def test_debit_credit_output(self):
 		bank_transaction = frappe.get_doc(

erpnext/accounts/doctype/bank_transaction_rule/bank_transaction_rule.py

@@ -9,6 +9,48 @@ from frappe.model.document import Document
 
 from erpnext.accounts.doctype.bank_transaction.bank_transaction import BankTransaction
 
+PLAIN_NUMBER_PATTERN = re.compile(r"^-?\d+(\.\d+)?$")
+# Tokens accepted by safe-expr-eval on the frontend (must stay in sync).
+ALLOWED_FORMULA_TOKEN = re.compile(r"\s+|transaction_amount|\d+(?:\.\d+)?|[+\-*/%^()]")
+PYTHON_ONLY_OPERATORS = ("**", "//")
+
+
+def _is_expr_eval_formula(formula: str) -> bool:
+	position = 0
+	while position < len(formula):
+		match = ALLOWED_FORMULA_TOKEN.match(formula, position)
+		if not match:
+			return False
+		position = match.end()
+
+	return formula.count("(") == formula.count(")")
+
+
+def validate_amount_formula(formula: str) -> None:
+	if not formula:
+		return
+
+	stripped = formula.strip()
+	if PLAIN_NUMBER_PATTERN.match(stripped):
+		return
+
+	if any(operator in stripped for operator in PYTHON_ONLY_OPERATORS):
+		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
+
+	if not _is_expr_eval_formula(stripped):
+		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
+
+	# expr-eval uses ^ for exponentiation; translate for a smoke-test evaluation only.
+	python_formula = stripped.replace("^", "**")
+
+	try:
+		result = frappe.safe_eval(python_formula, eval_globals=None, eval_locals={"transaction_amount": 1})
+	except Exception:
+		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
+
+	if not isinstance(result, (int | float)):
+		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
+
 
 class BankTransactionRule(Document):
 	# begin: auto-generated types
@@ -86,6 +128,11 @@ class BankTransactionRule(Document):
 							frappe.throw(
 								_("The last account row must not have any debit or credit amounts set.")
 							)
+					else:
+						if account.debit:
+							validate_amount_formula(account.debit)
+						if account.credit:
+							validate_amount_formula(account.credit)
 
 		# Validate regex
 		for rule in self.description_rules:

erpnext/accounts/doctype/bank_transaction_rule/test_bank_transaction_rule.py

@@ -231,3 +231,45 @@ class TestBankTransactionRule(ERPNextTestSuite, AccountsTestMixin):
 		doc = self._rule("bad_rx", [{"check": "Regex", "value": "["}])
 		with self.assertRaises(ValidationError):
 			doc.insert()
+
+	def _multiple_accounts_rule(self, prefix: str, accounts, **fields):
+		return self._rule(
+			prefix,
+			[{"check": "Contains", "value": "x"}],
+			classify_as="Bank Entry",
+			bank_entry_type="Multiple Accounts",
+			accounts=accounts,
+			**fields,
+		)
+
+	def test_validate_bank_entry_multiple_valid_amount_formulas(self):
+		doc = self._multiple_accounts_rule(
+			"be_formula",
+			accounts=[
+				{"account": self.bank, "debit": "200", "credit": ""},
+				{"account": self.cash, "debit": "", "credit": "transaction_amount * 0.25"},
+				{"account": self.cash, "debit": "", "credit": ""},
+			],
+		)
+		doc.insert()
+		self.assertTrue(doc.name)
+
+	def test_validate_bank_entry_multiple_invalid_amount_formulas(self):
+		malicious_formulas = [
+			"__import__('os')",
+			"eval('1+1')",
+			"open('/etc/passwd')",
+			"transaction_amount ** 2",
+			"transaction_amount // 2",
+		]
+		for formula in malicious_formulas:
+			with self.subTest(formula=formula):
+				doc = self._multiple_accounts_rule(
+					"be_bad_formula",
+					accounts=[
+						{"account": self.bank, "debit": formula, "credit": ""},
+						{"account": self.cash, "debit": "", "credit": ""},
+					],
+				)
+				with self.assertRaises(ValidationError):
+					doc.insert()

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js

@@ -22,17 +22,27 @@ frappe.ui.form.on("Exchange Rate Revaluation", {
 	refresh: function (frm) {
 		if (frm.doc.docstatus == 1) {
 			frappe.call({
-				method: "check_journal_entry_condition",
+				method: "check_journal_and_reversal",
 				doc: frm.doc,
 				callback: function (r) {
 					if (r.message) {
-						frm.add_custom_button(
-							__("Journal Entries"),
-							function () {
-								return frm.events.make_jv(frm);
-							},
-							__("Create")
-						);
+						if (!r.message.journals_posted) {
+							frm.add_custom_button(
+								__("Journal Entries"),
+								function () {
+									return frm.events.make_jv(frm);
+								},
+								__("Create")
+							);
+						} else if (!r.message.reversals_posted) {
+							frm.add_custom_button(
+								__("Reversal Journal Entries"),
+								function () {
+									return frm.events.make_reverse_journal(frm);
+								},
+								__("Create")
+							);
+						}
 					}
 				},
 			});
@@ -100,6 +110,14 @@ frappe.ui.form.on("Exchange Rate Revaluation", {
 			},
 		});
 	},
+	make_reverse_journal: function (frm) {
+		frappe.call({
+			method: "make_reverse_journal",
+			doc: frm.doc,
+			freeze: true,
+			freeze_message: __("Reversing Journals..."),
+		});
+	},
 });
 
 frappe.ui.form.on("Exchange Rate Revaluation Account", {

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -8,7 +8,7 @@ from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
 from frappe.query_builder import Criterion, Order
 from frappe.query_builder.functions import NullIf, Sum
-from frappe.utils import flt, get_link_to_form
+from frappe.utils import flt, get_link_to_form, nowdate
 
 import erpnext
 from erpnext.accounts.doctype.journal_entry.journal_entry import get_balance_on
@@ -90,25 +90,31 @@ class ExchangeRateRevaluation(Document):
 		)
 
 	def on_cancel(self):
-		self.ignore_linked_doctypes = "GL Entry"
+		self.ignore_linked_doctypes = ["GL Entry", "Payment Ledger Entry"]
 
 	@frappe.whitelist()
-	def check_journal_entry_condition(self):
+	def check_journal_and_reversal(self):
 		exchange_gain_loss_account = self.get_for_unrealized_gain_loss_account()
 
+		journals_posted = False
+		reversals_posted = False
+
+		je = qb.DocType("Journal Entry")
 		jea = qb.DocType("Journal Entry Account")
 		journals = (
-			qb.from_(jea)
-			.select(jea.parent)
+			qb.from_(je)
+			.join(jea)
+			.on(je.name == jea.parent)
+			.select(je.name)
 			.distinct()
 			.where(
 				(jea.reference_type == "Exchange Rate Revaluation")
 				& (jea.reference_name == self.name)
 				& (jea.docstatus == 1)
+				& (je.reversal_of.isnull())  # omit journals that have reversals
 			)
-			.run()
+			.run(pluck="name")
 		)
-
 		if journals:
 			gle = qb.DocType("GL Entry")
 			total_amt = (
@@ -123,12 +129,31 @@ class ExchangeRateRevaluation(Document):
 				.run()
 			)
 
-			if total_amt and total_amt[0][0] != self.total_gain_loss:
-				return True
+			if total_amt and total_amt[0][0] == self.total_gain_loss:
+				journals_posted = True
 			else:
-				return False
+				journals_posted = False
 
-		return True
+		# reverse journals
+		reverse_journals = (
+			qb.from_(je)
+			.join(jea)
+			.on(je.name == jea.parent)
+			.select(je.name)
+			.where(
+				(jea.reference_type == "Exchange Rate Revaluation")
+				& (jea.reference_name == self.name)
+				& (jea.docstatus == 1)
+				& (je.reversal_of.notnull())
+			)
+			.run(pluck="name")
+		)
+		if reverse_journals:
+			reversals_posted = True
+		else:
+			reversals_posted = False
+
+		return {"journals_posted": journals_posted, "reversals_posted": reversals_posted}
 
 	def fetch_and_calculate_accounts_data(self):
 		accounts = self.get_accounts_data()
@@ -342,6 +367,7 @@ class ExchangeRateRevaluation(Document):
 
 	@frappe.whitelist()
 	def make_jv_entries(self):
+		frappe.has_permission("Journal Entry", "write", throw=True)
 		zero_balance_jv = self.make_jv_for_zero_balance()
 		if zero_balance_jv:
 			frappe.msgprint(
@@ -568,6 +594,38 @@ class ExchangeRateRevaluation(Document):
 		journal_entry.save()
 		return journal_entry
 
+	@frappe.whitelist()
+	def make_reverse_journal(self):
+		frappe.has_permission("Journal Entry", "write", throw=True)
+		je = qb.DocType("Journal Entry")
+		jea = qb.DocType("Journal Entry Account")
+		journals = (
+			qb.from_(je)
+			.join(jea)
+			.on(je.name == jea.parent)
+			.select(je.name)
+			.distinct()
+			.where(
+				(jea.reference_type == "Exchange Rate Revaluation")
+				& (jea.reference_name == self.name)
+				& (jea.docstatus == 1)
+				& (je.reversal_of.isnull())  # omit journals that have reversals
+			)
+			.run(pluck="name")
+		)
+		if journals:
+			from erpnext.accounts.doctype.journal_entry.journal_entry import make_reverse_journal_entry
+
+			for x in journals:
+				reversal = make_reverse_journal_entry(x)
+				reversal.posting_date = nowdate()
+				reversal.submit()
+				frappe.msgprint(
+					_("Revaluation journal for {0} has been created: {1}").format(
+						frappe.bold(x), get_link_to_form("Journal Entry", reversal.name)
+					)
+				)
+
 
 def calculate_exchange_rate_using_last_gle(company, account, party_type, party):
 	"""

erpnext/accounts/doctype/exchange_rate_revaluation/test_exchange_rate_revaluation.py

@@ -132,7 +132,8 @@ class TestExchangeRateRevaluation(ERPNextTestSuite, AccountsTestMixin):
 		err = err.save().submit()
 
 		# Create JV for ERR
-		self.assertTrue(err.check_journal_entry_condition())
+		ret = err.check_journal_and_reversal()
+		self.assertFalse(ret.get("journals_posted"))
 		err_journals = err.make_jv_entries()
 		je = frappe.get_doc("Journal Entry", err_journals.get("zero_balance_jv"))
 		je = je.submit()
@@ -221,7 +222,8 @@ class TestExchangeRateRevaluation(ERPNextTestSuite, AccountsTestMixin):
 		err = err.save().submit()
 
 		# Create JV for ERR
-		self.assertTrue(err.check_journal_entry_condition())
+		ret = err.check_journal_and_reversal()
+		self.assertFalse(ret.get("journals_posted"))
 		err_journals = err.make_jv_entries()
 		je = frappe.get_doc("Journal Entry", err_journals.get("zero_balance_jv"))
 		je = je.submit()

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -71,7 +71,7 @@ frappe.ui.form.on("Journal Entry", {
 
 	refresh: function (frm) {
 		if (frm.doc.reversal_of && (frm.is_new() || frm.doc.docstatus == 0)) {
-			frm.set_read_only();
+			erpnext.journal_entry.lock_reversal_entry(frm);
 		}
 
 		erpnext.toggle_naming_series();
@@ -564,6 +564,13 @@ $.extend(erpnext.journal_entry, {
 		});
 	},
 
+	lock_reversal_entry: function (frm) {
+		frm.fields
+			.filter((field) => field.has_input)
+			.forEach((field) => frm.set_df_property(field.df.fieldname, "read_only", 1));
+		frm.set_df_property("accounts", "read_only", 1);
+	},
+
 	set_debit_credit_in_company_currency: function (frm, cdt, cdn) {
 		var row = locals[cdt][cdn];
 

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -417,11 +417,12 @@ class JournalEntry(AccountsController):
 
 	def update_journal_entry_link_on_depr_schedule(self, asset, je_row):
 		depr_schedule = get_depr_schedule(asset.name, "Active", self.finance_book)
+		precision = je_row.precision("debit")
 		for d in depr_schedule or []:
 			if (
 				d.schedule_date == self.posting_date
 				and not d.journal_entry
-				and d.depreciation_amount == flt(je_row.debit)
+				and flt(d.depreciation_amount, precision) == flt(je_row.debit, precision)
 			):
 				frappe.db.set_value("Depreciation Schedule", d.name, "journal_entry", self.name)
 

erpnext/accounts/doctype/journal_entry/journal_entry_list.js

@@ -1,7 +1,10 @@
 frappe.listview_settings["Journal Entry"] = {
-	add_fields: ["voucher_type", "posting_date", "total_debit", "company", "remark"],
+	add_fields: ["voucher_type", "posting_date", "total_debit", "company", "remark", "reversal_of"],
 	get_indicator: function (doc) {
 		if (doc.docstatus === 1) {
+			if (doc.reversal_of && doc.voucher_type == "Exchange Rate Revaluation") {
+				return [__("Reversal Of Exchange Rate Revaluation"), "blue"];
+			}
 			return [__(doc.voucher_type), "blue", `voucher_type,=,${doc.voucher_type}`];
 		}
 	},

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js

@@ -24,15 +24,22 @@ frappe.ui.form.on("Opening Invoice Creation Tool", {
 				setTimeout(
 					() => {
 						frm.doc.import_in_progress = false;
-						frm.clear_table("invoices");
-						frm.refresh_fields();
 						frm.page.clear_indicator();
 						frm.dashboard.hide_progress();
 
-						if (frm.doc.invoice_type == "Sales") {
-							frappe.msgprint(__("Opening Sales Invoices have been created."));
+						if (!data.errors) {
+							frm.clear_table("invoices");
+							frm.refresh_fields();
+							const message =
+								frm.doc.invoice_type == "Sales"
+									? __("Opening Sales Invoice(s) have been created.")
+									: __("Opening Purchase Invoice(s) have been created.");
+							frappe.show_alert({
+								message: message,
+								indicator: "green",
+							});
 						} else {
-							frappe.msgprint(__("Opening Purchase Invoices have been created."));
+							frm.refresh_fields();
 						}
 					},
 					1500,

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py

@@ -281,12 +281,20 @@ class OpeningInvoiceCreationTool(Document):
 def start_import(invoices):
 	errors = 0
 	names = []
+	total = len(invoices)
 	for idx, d in enumerate(invoices):
+		# Scope each invoice to a savepoint so a failure only undoes that invoice.
+		# A plain rollback() would discard the whole transaction — including invoices
+		# imported earlier in this batch and the error logs of earlier failures (the
+		# latter only survive on mariadb because the Error Log table is MyISAM; on
+		# postgres they would be lost). Rolling back to a savepoint keeps both.
+		savepoint = f"opening_invoice_{frappe.generate_hash(length=8)}"
+		frappe.db.savepoint(savepoint)
+		is_last = idx == total - 1
 		try:
 			invoice_number = None
 			if d.invoice_number:
 				invoice_number = d.invoice_number
-			publish(idx, len(invoices), d.doctype)
 			doc = frappe.get_doc(d)
 			doc.flags.ignore_mandatory = True
 			doc.insert(set_name=invoice_number)
@@ -294,10 +302,12 @@ def start_import(invoices):
 			if not frappe.in_test:
 				frappe.db.commit()
 			names.append(doc.name)
+			publish(idx, total, d.doctype, errors=errors if is_last else None)
 		except Exception:
 			errors += 1
 			frappe.db.rollback()
 			doc.log_error("Opening invoice creation failed")
+			publish(idx, total, d.doctype, errors=errors if is_last else None)
 	if errors:
 		frappe.msgprint(
 			_("You had {} errors while creating opening invoices. Check {} for more details").format(
@@ -309,7 +319,7 @@ def start_import(invoices):
 	return names
 
 
-def publish(index, total, doctype):
+def publish(index, total, doctype, errors=None):
 	frappe.publish_realtime(
 		"opening_invoice_creation_progress",
 		dict(
@@ -317,6 +327,7 @@ def publish(index, total, doctype):
 			message=_("Creating {} out of {} {}").format(index + 1, total, doctype),
 			count=index + 1,
 			total=total,
+			errors=errors,
 		),
 		user=frappe.session.user,
 	)

erpnext/accounts/doctype/opening_invoice_creation_tool_item/opening_invoice_creation_tool_item.json

@@ -82,6 +82,7 @@
    "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Outstanding Amount",
+   "options": "Company:company:default_currency",
    "reqd": 1
   },
   {
@@ -136,7 +137,7 @@
  ],
  "istable": 1,
  "links": [],
- "modified": "2026-04-29 17:08:15.617047",
+ "modified": "2026-07-02 15:17:11.938499",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Opening Invoice Creation Tool Item",

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -2712,6 +2712,9 @@ def get_party_details(company, party_type, party, date, cost_center=None):
 	if not frappe.db.exists(party_type, party):
 		frappe.throw(_("{0} {1} does not exist").format(_(party_type), party))
 
+	ptype = "select" if frappe.only_has_select_perm(party_type) else "read"
+	frappe.has_permission(party_type, ptype, party, throw=True)
+
 	party_account = get_party_account(party_type, party, company)
 	account_currency = get_account_currency(party_account)
 	_party_name = "title" if party_type == "Shareholder" else party_type.lower() + "_name"
@@ -2719,7 +2722,7 @@ def get_party_details(company, party_type, party, date, cost_center=None):
 
 	if party_type in ["Customer", "Supplier"]:
 		party_bank_account = get_party_bank_account(party_type, party)
-		bank_account = get_default_company_bank_account(company, party_type, party)
+		bank_account = get_default_company_bank_account(company, party_type, party, ignore_permissions=False)
 
 	return {
 		"party_account": party_account,
@@ -2811,9 +2814,7 @@ def get_reference_details(
 			exchange_rate = get_exchange_rate(party_account_currency, company_currency, ref_doc.posting_date)
 		else:
 			exchange_rate = 1
-			outstanding_amount, total_amount = get_outstanding_on_journal_entry(
-				reference_name, party_type, party
-			)
+		outstanding_amount, total_amount = get_outstanding_on_journal_entry(reference_name, party_type, party)
 
 	elif reference_doctype == "Payment Entry":
 		if reverse_payment_details := frappe.db.get_all(

erpnext/accounts/doctype/payment_ledger_entry/test_payment_ledger_entry.py

@@ -10,75 +10,22 @@ from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_ent
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
-from erpnext.stock.doctype.item.test_item import create_item
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestPaymentLedgerEntry(ERPNextTestSuite):
 	def setUp(self):
 		self.ple = qb.DocType("Payment Ledger Entry")
-		self.create_company()
-		self.create_item()
-		self.create_customer()
-
-	def create_company(self):
-		company_name = "_Test Payment Ledger"
-		company = None
-		if frappe.db.exists("Company", company_name):
-			company = frappe.get_doc("Company", company_name)
-		else:
-			company = frappe.get_doc(
-				{
-					"doctype": "Company",
-					"company_name": company_name,
-					"country": "India",
-					"default_currency": "INR",
-					"create_chart_of_accounts_based_on": "Standard Template",
-					"chart_of_accounts": "Standard",
-				}
-			)
-			company = company.save()
-
-		self.company = company.name
-		self.cost_center = company.cost_center
-		self.warehouse = "All Warehouses - _PL"
-		self.income_account = "Sales - _PL"
-		self.expense_account = "Cost of Goods Sold - _PL"
-		self.debit_to = "Debtors - _PL"
-		self.creditors = "Creditors - _PL"
-
-		# create bank account
-		if frappe.db.exists("Account", "HDFC - _PL"):
-			self.bank = "HDFC - _PL"
-		else:
-			bank_acc = frappe.get_doc(
-				{
-					"doctype": "Account",
-					"account_name": "HDFC",
-					"parent_account": "Bank Accounts - _PL",
-					"company": self.company,
-				}
-			)
-			bank_acc.save()
-			self.bank = bank_acc.name
-
-	def create_item(self):
-		item_name = "_Test PL Item"
-		item = create_item(
-			item_code=item_name, is_stock_item=0, company=self.company, warehouse=self.warehouse
-		)
-		self.item = item if isinstance(item, str) else item.item_code
-
-	def create_customer(self):
-		name = "_Test PL Customer"
-		if frappe.db.exists("Customer", name):
-			self.customer = name
-		else:
-			customer = frappe.new_doc("Customer")
-			customer.customer_name = name
-			customer.type = "Individual"
-			customer.save()
-			self.customer = customer.name
+		self.company = "_Test Company"
+		self.cost_center = "Main - _TC"
+		self.warehouse = "Stores - _TC"
+		self.income_account = "Sales - _TC"
+		self.expense_account = "Cost of Goods Sold - _TC"
+		self.debit_to = "Debtors - _TC"
+		self.creditors = "Creditors - _TC"
+		self.bank = "Cash - _TC"
+		self.item = "_Test Item"
+		self.customer = "_Test Customer"
 
 	def create_sales_invoice(
 		self, qty=1, rate=100, posting_date=None, do_not_save=False, do_not_submit=False
@@ -151,18 +98,6 @@ class TestPaymentLedgerEntry(ERPNextTestSuite):
 		)
 		return so
 
-	def clear_old_entries(self):
-		doctype_list = [
-			"GL Entry",
-			"Payment Ledger Entry",
-			"Sales Invoice",
-			"Purchase Invoice",
-			"Payment Entry",
-			"Journal Entry",
-		]
-		for doctype in doctype_list:
-			qb.from_(qb.DocType(doctype)).delete().where(qb.DocType(doctype).company == self.company).run()
-
 	def create_journal_entry(self, acc1=None, acc2=None, amount=0, posting_date=None, cost_center=None):
 		je = frappe.new_doc("Journal Entry")
 		je.posting_date = posting_date or nowdate()

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -6,8 +6,10 @@ import frappe
 from frappe import _, msgprint, qb
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
+from frappe.permissions import get_allowed_docs_for_doctype, get_user_permissions
 from frappe.query_builder import Case, Criterion
 from frappe.query_builder.custom import ConstantColumn
+from frappe.query_builder.functions import IfNull
 from frappe.utils import flt, fmt_money, get_link_to_form, getdate, nowdate, today
 
 import erpnext
@@ -74,6 +76,10 @@ class PaymentReconciliation(Document):
 		self.ple_posting_date_filter = []
 		self.dimensions = get_dimensions(with_cost_center_and_project=True)[0]
 
+	@property
+	def user_permissions(self):
+		return get_user_permissions(frappe.session.user)
+
 	def load_from_db(self):
 		# 'modified' attribute is required for `run_doc_method` to work properly.
 		doc_dict = frappe._dict(
@@ -153,6 +159,22 @@ class PaymentReconciliation(Document):
 
 		self.add_payment_entries(non_reconciled_payments)
 
+	def get_permitted_dimension_values(self, document_type, reference_doctype):
+		return get_allowed_docs_for_doctype(self.user_permissions.get(document_type, []), reference_doctype)
+
+	def validate_permitted_dimension_value(self, document_type, value, allowed):
+		if value and allowed and value not in allowed:
+			frappe.throw(
+				_("You do not have enough permission to access {0}: {1}").format(_(document_type), value),
+				frappe.PermissionError,
+			)
+
+	def get_user_permission_dimension_condition(self, field, allowed):
+		value_condition = field.isin(allowed)
+		if frappe.get_system_settings("apply_strict_user_permissions"):
+			return value_condition
+		return (IfNull(field, "") == "") | value_condition
+
 	def get_payment_entries(self):
 		party_account = [self.receivable_payable_account]
 
@@ -176,8 +198,13 @@ class PaymentReconciliation(Document):
 		dimensions = {}
 		for x in self.dimensions:
 			dimension = x.fieldname
-			if self.get(dimension):
-				dimensions.update({dimension: self.get(dimension)})
+			allowed = self.get_permitted_dimension_values(x.document_type, "Payment Entry")
+			if value := self.get(dimension):
+				self.validate_permitted_dimension_value(x.document_type, value, allowed)
+				dimensions[dimension] = value
+			elif allowed:
+				dimensions[dimension] = allowed
+
 		condition.update({"accounting_dimensions": dimensions})
 
 		payment_entries = get_advance_payment_entries_for_regional(
@@ -201,8 +228,12 @@ class PaymentReconciliation(Document):
 		# Dimension filters
 		for x in self.dimensions:
 			dimension = x.fieldname
-			if self.get(dimension):
-				conditions.append(jea[dimension] == self.get(dimension))
+			allowed = self.get_permitted_dimension_values(x.document_type, "Journal Entry Account")
+			if value := self.get(dimension):
+				self.validate_permitted_dimension_value(x.document_type, value, allowed)
+				conditions.append(jea[dimension] == value)
+			elif allowed:
+				conditions.append(self.get_user_permission_dimension_condition(jea[dimension], allowed))
 
 		if self.payment_name:
 			conditions.append(je.name.like(f"%%{self.payment_name}%%"))
@@ -746,8 +777,15 @@ class PaymentReconciliation(Document):
 		ple = qb.DocType("Payment Ledger Entry")
 		for x in self.dimensions:
 			dimension = x.fieldname
-			if self.get(dimension) and frappe.db.has_column("Payment Ledger Entry", dimension):
-				self.accounting_dimension_filter_conditions.append(ple[dimension] == self.get(dimension))
+			if frappe.db.has_column("Payment Ledger Entry", dimension):
+				allowed = self.get_permitted_dimension_values(x.document_type, "Payment Ledger Entry")
+				if value := self.get(dimension):
+					self.validate_permitted_dimension_value(x.document_type, value, allowed)
+					self.accounting_dimension_filter_conditions.append(ple[dimension] == value)
+				elif allowed:
+					self.accounting_dimension_filter_conditions.append(
+						self.get_user_permission_dimension_condition(ple[dimension], allowed)
+					)
 
 	def build_qb_filter_conditions(self, get_invoices=False, get_return_invoices=False):
 		self.common_filter_conditions.clear()
@@ -796,10 +834,17 @@ class PaymentReconciliation(Document):
 
 
 def reconcile_dr_cr_note(dr_cr_notes, company, active_dimensions=None):
+	allocated_amount_precision = get_field_precision(
+		frappe.get_meta("Payment Reconciliation Allocation").get_field("allocated_amount")
+	)
 	for inv in dr_cr_notes:
 		if (
-			abs(frappe.db.get_value(inv.voucher_type, inv.voucher_no, "outstanding_amount"))
-			< inv.allocated_amount
+			flt(
+				abs(frappe.db.get_value(inv.voucher_type, inv.voucher_no, "outstanding_amount"))
+				- inv.allocated_amount,
+				allocated_amount_precision,
+			)
+			< 0
 		):
 			frappe.throw(
 				_("{0} has been modified after you pulled it. Please pull it again.").format(inv.voucher_type)

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -4,7 +4,7 @@
 
 import frappe
 from frappe import qb
-from frappe.utils import add_days, add_years, flt, getdate, nowdate, today
+from frappe.utils import add_days, add_years, cint, flt, getdate, nowdate, today
 from frappe.utils.data import getdate as convert_to_date
 
 from erpnext import get_default_cost_center
@@ -51,6 +51,7 @@ class TestPaymentReconciliation(ERPNextTestSuite):
 		sinv = create_sales_invoice(
 			qty=qty,
 			rate=rate,
+			posting_date=posting_date,
 			company=self.company,
 			customer=self.customer,
 			item_code=self.item,
@@ -1105,6 +1106,101 @@ class TestPaymentReconciliation(ERPNextTestSuite):
 		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
 		self.assertCountEqual(payment_vouchers, [je2.name, pe2.name])
 
+	def test_user_permission_on_accounting_dimension_filters_vouchers(self):
+		test_user = "test@example.com"
+		permitted_ccs = ["_Test Cost Center - _TC", "_Test Cost Center 2 - _TC"]
+		restricted_cc = "_Test Write Off Cost Center - _TC"
+		existing_apply_strict_user_permissions = cint(
+			frappe.db.get_single_value("System Settings", "apply_strict_user_permissions")
+		)
+		self.addCleanup(
+			frappe.db.set_single_value,
+			"System Settings",
+			"apply_strict_user_permissions",
+			existing_apply_strict_user_permissions,
+		)
+		transaction_date = nowdate()
+		rate = 100
+
+		def make_invoice(cost_center):
+			si = self.create_sales_invoice(
+				qty=1, rate=rate, posting_date=transaction_date, do_not_submit=True
+			)
+			si.cost_center = cost_center
+			for row in si.items:
+				row.cost_center = cost_center
+			return si.submit()
+
+		def make_payment(cost_center):
+			pe = self.create_payment_entry(posting_date=transaction_date, amount=rate)
+			pe.cost_center = cost_center
+			return pe.save().submit()
+
+		def make_journal(cost_center):
+			je = self.create_journal_entry(
+				self.bank, self.debit_to, 100, transaction_date, cost_center=cost_center
+			)
+			je.accounts[1].party_type = "Customer"
+			je.accounts[1].party = self.customer
+			return je.save().submit()
+
+		# Vouchers tagged with the two permitted cost centers
+		si_allowed = make_invoice(permitted_ccs[0])
+		pe_allowed = make_payment(permitted_ccs[1])
+		je_allowed = make_journal(permitted_ccs[0])
+
+		# Vouchers tagged with the restricted cost center
+		si_restricted = make_invoice(restricted_cc)
+		pe_restricted = make_payment(restricted_cc)
+		je_restricted = make_journal(restricted_cc)
+
+		# Payment entry with a BLANK cost center
+		pe_blank = make_payment(None)
+
+		for cc in permitted_ccs:
+			frappe.permissions.add_user_permission("Cost Center", cc, test_user)
+
+		# Without strict user permissions
+		frappe.db.set_single_value("System Settings", "apply_strict_user_permissions", 0)
+		with self.set_user(test_user):
+			pr = self.create_payment_reconciliation()
+			pr.get_unreconciled_entries()
+
+		invoice_numbers = [x.get("invoice_number") for x in pr.get("invoices")]
+		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
+		self.assertIn(si_allowed.name, invoice_numbers)
+		self.assertIn(pe_allowed.name, payment_vouchers)
+		self.assertIn(je_allowed.name, payment_vouchers)
+		self.assertIn(pe_blank.name, payment_vouchers)
+		self.assertNotIn(si_restricted.name, invoice_numbers)
+		self.assertNotIn(pe_restricted.name, payment_vouchers)
+		self.assertNotIn(je_restricted.name, payment_vouchers)
+
+		# With strict user permissions
+		frappe.db.set_single_value("System Settings", "apply_strict_user_permissions", 1)
+		with self.set_user(test_user):
+			pr = self.create_payment_reconciliation()
+			pr.get_unreconciled_entries()
+
+		invoice_numbers = [x.get("invoice_number") for x in pr.get("invoices")]
+		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
+		self.assertIn(si_allowed.name, invoice_numbers)
+		self.assertIn(pe_allowed.name, payment_vouchers)
+		self.assertIn(je_allowed.name, payment_vouchers)
+		self.assertNotIn(pe_blank.name, payment_vouchers)
+		self.assertNotIn(si_restricted.name, invoice_numbers)
+		self.assertNotIn(pe_restricted.name, payment_vouchers)
+		self.assertNotIn(je_restricted.name, payment_vouchers)
+
+		# with restricted dimension as a filter
+		with self.set_user(test_user):
+			pr = self.create_payment_reconciliation()
+			pr.cost_center = restricted_cc
+			self.assertRaises(frappe.PermissionError, pr.get_unreconciled_entries)
+
+		for cc in permitted_ccs:
+			frappe.permissions.remove_user_permission("Cost Center", cc, test_user)
+
 	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{
@@ -2018,7 +2114,7 @@ class TestPaymentReconciliation(ERPNextTestSuite):
 		pr.reconcile()
 
 		si.reload()
-		self.assertEqual(si.status, "Partly Paid")
+		self.assertEqual(si.status, "Overdue")
 		# check PR tool output post reconciliation
 		self.assertEqual(len(pr.get("invoices")), 1)
 		self.assertEqual(pr.get("invoices")[0].get("outstanding_amount"), 120)
@@ -2414,6 +2510,76 @@ class TestPaymentReconciliation(ERPNextTestSuite):
 		self.assertEqual(flt(pr.allocation[0].difference_amount), 5000.0)
 		pr.reconcile()
 
+	def test_cr_note_split_across_invoices_floating_point_precision(self):
+		"""Regression: when a credit note is split across multiple invoices, floating-point
+		arithmetic (150 - 8.45 - 90.72 = 50.83000000000001) must not cause reconcile() to fail.
+
+		The test environment rounds INR totals to whole rupees (smallest_currency_fraction_value=0),
+		so the invoices are created with round-number totals (100, 200, 100) and then partially paid
+		down to the decimal outstanding amounts (8.45, 90.72, 72.57) via payment entries.
+		"""
+		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
+
+		# Create invoices on different posting dates to control sort-order in Payment Reconciliation
+		# (invoices are sorted by posting_date ascending, so si_a is processed first).
+		# Processing order 8.45 → 90.72 → 72.57 produces the float chain:
+		#   150 - 8.45 = 141.55  →  141.55 - 90.72 = 50.83000000000001
+		# The last allocation row will therefore carry allocated_amount = 50.83000000000001.
+		si_a = self.create_sales_invoice(qty=1, rate=100, posting_date=add_days(nowdate(), -2))
+		si_b = self.create_sales_invoice(qty=1, rate=200, posting_date=add_days(nowdate(), -1))
+		si_c = self.create_sales_invoice(qty=1, rate=100, posting_date=nowdate())
+
+		# Partially pay each invoice so the remaining outstanding is a clean decimal value.
+		# INR rounds the invoice total to a whole rupee, so we achieve decimal outstandings
+		# by subtracting a decimal-valued payment from the integer total:
+		#   100 - 91.55 = 8.45
+		#   200 - 109.28 = 90.72
+		#   100 - 27.43 = 72.57
+		for si, partial_paid in ((si_a, 91.55), (si_b, 109.28), (si_c, 27.43)):
+			pe = get_payment_entry(si.doctype, si.name)
+			pe.paid_amount = partial_paid
+			pe.received_amount = partial_paid
+			pe.references[0].allocated_amount = partial_paid
+			pe.save().submit()
+
+		cr_note = self.create_sales_invoice(
+			qty=-1, rate=150, posting_date=nowdate(), do_not_save=True, do_not_submit=True
+		)
+		cr_note.is_return = 1
+		cr_note = cr_note.save().submit()
+
+		pr = self.create_payment_reconciliation()
+		# Widen date range so all three invoices (oldest is -2 days) are fetched
+		pr.from_invoice_date = add_days(nowdate(), -2)
+		pr.to_invoice_date = nowdate()
+		pr.from_payment_date = nowdate()
+		pr.to_payment_date = nowdate()
+
+		pr.get_unreconciled_entries()
+		self.assertEqual(len(pr.invoices), 3)
+		self.assertEqual(len(pr.payments), 1)
+
+		invoices = [x.as_dict() for x in pr.invoices]
+		payments = [x.as_dict() for x in pr.payments]
+		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
+
+		# Credit note (150) covers all of si_a (8.45) and si_b (90.72), then partially si_c
+		self.assertEqual(len(pr.allocation), 3)
+		last_row = pr.allocation[-1]
+		# Last allocated amount should be ~50.83 (possibly 50.83000000000001 due to float arithmetic)
+		self.assertAlmostEqual(flt(last_row.allocated_amount), 50.83, places=2)
+
+		# reconcile() must not raise "has been modified after you pulled it" due to float imprecision
+		pr.reconcile()
+
+		si_a.reload()
+		si_b.reload()
+		si_c.reload()
+		self.assertEqual(si_a.outstanding_amount, 0)
+		self.assertEqual(si_b.outstanding_amount, 0)
+		# si_c is only partially settled: 72.57 - 50.83 = 21.74
+		self.assertAlmostEqual(si_c.outstanding_amount, 21.74, places=2)
+
 
 def create_fiscal_year(company, year_start_date, year_end_date):
 	fy_docname = frappe.db.exists(

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -379,6 +379,7 @@ class PaymentRequest(Document):
 			bank_amount=bank_amount,
 			created_from_payment_request=True,
 		)
+		payment_entry.set_missing_ref_details(force=True)
 
 		payment_entry.update(
 			{
@@ -957,6 +958,7 @@ def resend_payment_email(docname):
 @frappe.whitelist()
 def make_payment_entry(docname):
 	doc = frappe.get_doc("Payment Request", docname)
+	doc.check_permission("read")
 	return doc.create_payment_entry(submit=False).as_dict()
 
 

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -775,6 +775,22 @@ class TestPaymentRequest(ERPNextTestSuite):
 		pi.load_from_db()
 		self.assertEqual(pr_2.grand_total, pi.outstanding_amount)
 
+	def test_payment_entry_reference_details_fetched_from_invoice(self):
+		pi = make_purchase_invoice(currency="INR", qty=1, rate=94500)
+		pi.submit()
+
+		pr = make_payment_request(dt="Purchase Invoice", dn=pi.name, mute_email=1, submit_doc=0, return_doc=1)
+		pr.grand_total = 94000
+		pr.submit()
+
+		pe = pr.create_payment_entry(submit=False)
+
+		self.assertEqual(pe.references[0].reference_name, pi.name)
+		self.assertEqual(pe.references[0].total_amount, pi.grand_total)
+		self.assertEqual(pe.references[0].outstanding_amount, pi.outstanding_amount)
+		self.assertEqual(pe.references[0].allocated_amount, 94000)
+		self.assertEqual(pe.paid_amount, 94000)
+
 	def test_consider_journal_entry_and_return_invoice(self):
 		from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -19,7 +19,6 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		frappe.db.set_single_value("Accounts Settings", "use_legacy_controller_for_pcv", 1)
 
 	def test_closing_entry(self):
-		company = create_company()
 		cost_center = create_cost_center("Test Cost Center 1")
 
 		jv1 = make_journal_entry(
@@ -28,10 +27,10 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center,
-			company=company,
+			company="Test PCV Company",
 			save=False,
 		)
-		jv1.company = company
+		jv1.company = "Test PCV Company"
 		jv1.save()
 		jv1.submit()
 
@@ -41,10 +40,10 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cost of Goods Sold - TPC",
 			account2="Cash - TPC",
 			cost_center=cost_center,
-			company=company,
+			company="Test PCV Company",
 			save=False,
 		)
-		jv2.company = company
+		jv2.company = "Test PCV Company"
 		jv2.save()
 		jv2.submit()
 
@@ -68,14 +67,13 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		self.assertEqual(pcv_gle, expected_gle)
 
 	def test_cost_center_wise_posting(self):
-		company = create_company()
 		surplus_account = create_account()
 
 		cost_center1 = create_cost_center("Main")
 		cost_center2 = create_cost_center("Western Branch")
 
 		create_sales_invoice(
-			company=company,
+			company="Test PCV Company",
 			cost_center=cost_center1,
 			income_account="Sales - TPC",
 			expense_account="Cost of Goods Sold - TPC",
@@ -86,7 +84,7 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			posting_date="2021-03-15",
 		)
 		create_sales_invoice(
-			company=company,
+			company="Test PCV Company",
 			cost_center=cost_center2,
 			income_account="Sales - TPC",
 			expense_account="Cost of Goods Sold - TPC",
@@ -131,12 +129,11 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		)
 
 	def test_period_closing_with_finance_book_entries(self):
-		company = create_company()
 		surplus_account = create_account()
 		cost_center = create_cost_center("Test Cost Center 1")
 
 		create_sales_invoice(
-			company=company,
+			company="Test PCV Company",
 			income_account="Sales - TPC",
 			expense_account="Cost of Goods Sold - TPC",
 			cost_center=cost_center,
@@ -153,9 +150,9 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			amount=400,
 			cost_center=cost_center,
 			posting_date="2021-03-15",
-			company=company,
+			company="Test PCV Company",
 		)
-		jv.company = company
+		jv.company = "Test PCV Company"
 		jv.finance_book = create_finance_book().name
 		jv.save()
 		jv.submit()
@@ -182,7 +179,6 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		self.assertSequenceEqual(pcv_gle, expected_gle)
 
 	def test_gl_entries_restrictions(self):
-		company = create_company()
 		cost_center = create_cost_center("Test Cost Center 1")
 
 		self.make_period_closing_voucher(posting_date="2021-03-31")
@@ -193,16 +189,15 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center,
-			company=company,
+			company="Test PCV Company",
 			save=False,
 		)
-		jv1.company = company
+		jv1.company = "Test PCV Company"
 		jv1.save()
 
 		self.assertRaises(frappe.ValidationError, jv1.submit)
 
 	def test_closing_balance_with_dimensions_and_test_reposting_entry(self):
-		company = create_company()
 		cost_center1 = create_cost_center("Test Cost Center 1")
 		cost_center2 = create_cost_center("Test Cost Center 2")
 
@@ -212,10 +207,10 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center1,
-			company=company,
+			company="Test PCV Company",
 			save=False,
 		)
-		jv1.company = company
+		jv1.company = "Test PCV Company"
 		jv1.save()
 		jv1.submit()
 
@@ -225,10 +220,10 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center2,
-			company=company,
+			company="Test PCV Company",
 			save=False,
 		)
-		jv2.company = company
+		jv2.company = "Test PCV Company"
 		jv2.save()
 		jv2.submit()
 
@@ -255,11 +250,11 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center2,
-			company=company,
+			company="Test PCV Company",
 			save=False,
 		)
 
-		jv3.company = company
+		jv3.company = "Test PCV Company"
 		jv3.save()
 		jv3.submit()
 
@@ -294,12 +289,12 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		self.assertEqual(cc2_closing_balance.credit, 500)
 		self.assertEqual(cc2_closing_balance.credit_in_account_currency, 500)
 
-		warehouse = frappe.db.get_value("Warehouse", {"company": company}, "name")
+		warehouse = frappe.db.get_value("Warehouse", {"company": "Test PCV Company"}, "name")
 
 		repost_doc = frappe.get_doc(
 			{
 				"doctype": "Repost Item Valuation",
-				"company": company,
+				"company": "Test PCV Company",
 				"posting_date": "2020-03-15",
 				"based_on": "Item and Warehouse",
 				"item_code": "Test Item 1",
@@ -340,7 +335,6 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		{"enable_immutable_ledger": 1},
 	)
 	def test_immutable_ledger_reverse_entry_uses_passed_posting_date_after_pcv(self):
-		company = create_company()
 		cost_center = create_cost_center("Test Cost Center 1")
 
 		jv = make_journal_entry(
@@ -349,21 +343,24 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center,
-			company=company,
+			company="Test PCV Company",
 			save=False,
 		)
-		jv.company = company
+		jv.company = "Test PCV Company"
 		jv.save()
 		jv.submit()
 
 		self.make_period_closing_voucher(posting_date="2021-03-31")
 
-		# Passed posting_date is after PCV end date, so cancellation should not fail.
-		make_reverse_gl_entries(
-			voucher_type="Journal Entry",
-			voucher_no=jv.name,
-			posting_date="2022-01-01",
-		)
+		frappe.db.set_value("Company", "Test PCV Company", "accounts_frozen_till_date", "2021-12-31")
+
+		try:
+			make_reverse_gl_entries(
+				voucher_type="Journal Entry",
+				voucher_no=jv.name,
+			)
+		finally:
+			frappe.db.set_value("Company", "Test PCV Company", "accounts_frozen_till_date", None)
 
 		totals_after_cancel = frappe.db.sql(
 			"""
@@ -378,19 +375,6 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		self.assertEqual(totals_after_cancel.total_debit, totals_after_cancel.total_credit)
 
 
-def create_company():
-	company = frappe.get_doc(
-		{
-			"doctype": "Company",
-			"company_name": "Test PCV Company",
-			"country": "United States",
-			"default_currency": "USD",
-		}
-	)
-	company.insert(ignore_if_duplicate=True)
-	return company.name
-
-
 def create_account():
 	account = frappe.get_doc(
 		{

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -156,6 +156,24 @@ class PricingRule(Document):
 			if len(values) != len(set(values)):
 				frappe.throw(_("Duplicate {0} found in the table").format(self.apply_on))
 
+			if self.apply_on == "Item Code":
+				self.validate_template_with_variant(values)
+
+	def validate_template_with_variant(self, item_codes):
+		# throws if a template and its variant both exist in one rule
+		variants = frappe.get_all(
+			"Item",
+			filters={"name": ("in", item_codes), "variant_of": ("in", item_codes)},
+			fields=["name", "variant_of"],
+		)
+		if variants:
+			variant = variants[0]
+			frappe.throw(
+				_("Variant {0} and its template {1} cannot both be added to the same Pricing Rule").format(
+					frappe.bold(variant.name), frappe.bold(variant.variant_of)
+				)
+			)
+
 	def validate_mandatory(self):
 		if self.has_priority and not self.priority:
 			throw(_("Priority is mandatory"), frappe.MandatoryError, _("Please Set Priority"))

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -333,6 +333,31 @@ class TestPricingRule(ERPNextTestSuite):
 		details = get_item_details(args)
 		self.assertEqual(details.get("discount_percentage"), 17.5)
 
+	def test_pricing_rule_with_template_and_its_variant(self):
+		if not frappe.db.exists("Item", "Test Variant PRT"):
+			variant = frappe.new_doc("Item")
+			variant.item_code = "Test Variant PRT"
+			variant.item_name = "Test Variant PRT"
+			variant.item_group = "_Test Item Group"
+			variant.is_stock_item = 1
+			variant.variant_of = "_Test Variant Item"
+			variant.stock_uom = "_Test UOM"
+			variant.append("attributes", {"attribute": "Test Size", "attribute_value": "Medium"})
+			variant.insert()
+
+		rule = frappe.new_doc("Pricing Rule")
+		rule.title = "_Test Pricing Rule Template Variant"
+		rule.apply_on = "Item Code"
+		rule.currency = "USD"
+		rule.selling = 1
+		rule.rate_or_discount = "Discount Percentage"
+		rule.discount_percentage = 10
+		rule.company = "_Test Company"
+		rule.append("items", {"item_code": "_Test Variant Item"})
+		rule.append("items", {"item_code": "Test Variant PRT"})
+
+		self.assertRaises(frappe.ValidationError, rule.insert)
+
 	def test_pricing_rule_for_stock_qty(self):
 		test_record = {
 			"doctype": "Pricing Rule",

erpnext/accounts/doctype/process_period_closing_voucher/process_period_closing_voucher.py

@@ -89,50 +89,55 @@ class ProcessPeriodClosingVoucher(Document):
 		cancel_pcv_processing(self.name)
 
 
+def initialize_parallel_threads(docname: str):
+	threads = 4
+	timeout = frappe.db.get_single_value("Accounts Settings", "pcv_job_timeout") or 3600
+	ppcvd = qb.DocType("Process Period Closing Voucher Detail")
+
+	frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Running")
+
+	if normal_balances := (
+		qb.from_(ppcvd)
+		.select(ppcvd.name, ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
+		.where(ppcvd.parent.eq(docname) & ppcvd.status.eq("Queued"))
+		.orderby(ppcvd.parentfield, ppcvd.idx, ppcvd.processing_date)
+		.limit(threads)
+		.for_update(skip_locked=True)
+		.run(as_dict=True)
+	):
+		if not is_scheduler_inactive():
+			for x in normal_balances:
+				frappe.db.set_value(
+					"Process Period Closing Voucher Detail",
+					x.name,
+					"status",
+					"Running",
+				)
+				frappe.enqueue(
+					method="erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.process_individual_date",
+					queue="long",
+					timeout=timeout,
+					is_async=True,
+					enqueue_after_commit=True,
+					docname=docname,
+					row_name=x.name,
+					date=x.processing_date,
+					report_type=x.report_type,
+					parentfield=x.parentfield,
+				)
+			# keep transaction on PPCV and PPCVD short
+			# prevents concurrency errors - REPEATABLE READ
+			if not frappe.in_test:
+				frappe.db.commit()  # nosemgrep
+	else:
+		frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Completed")
+
+
 @frappe.whitelist()
 def start_pcv_processing(docname: str):
 	if frappe.db.get_value("Process Period Closing Voucher", docname, "status") in ["Queued", "Running"]:
-		frappe.has_permission("Process Payment Reconciliation", "write", doc=docname, throw=True)
-		frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Running")
-
-		timeout = frappe.db.get_single_value("Accounts Settings", "pcv_job_timeout") or 3600
-
-		ppcvd = qb.DocType("Process Period Closing Voucher Detail")
-		if normal_balances := (
-			qb.from_(ppcvd)
-			.select(ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
-			.where(ppcvd.parent.eq(docname) & ppcvd.status.eq("Queued"))
-			.orderby(ppcvd.parentfield, ppcvd.idx, ppcvd.processing_date)
-			.limit(4)
-			.for_update(skip_locked=True)
-			.run(as_dict=True)
-		):
-			if not is_scheduler_inactive():
-				for x in normal_balances:
-					frappe.db.set_value(
-						"Process Period Closing Voucher Detail",
-						{
-							"processing_date": x.processing_date,
-							"parent": docname,
-							"report_type": x.report_type,
-							"parentfield": x.parentfield,
-						},
-						"status",
-						"Running",
-					)
-					frappe.enqueue(
-						method="erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.process_individual_date",
-						queue="long",
-						timeout=timeout,
-						is_async=True,
-						enqueue_after_commit=True,
-						docname=docname,
-						date=x.processing_date,
-						report_type=x.report_type,
-						parentfield=x.parentfield,
-					)
-		else:
-			frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Completed")
+		frappe.has_permission("Process Period Closing Voucher", "write", doc=docname, throw=True)
+		initialize_parallel_threads(docname)
 
 
 @frappe.whitelist()
@@ -250,11 +255,11 @@ def get_gle_for_closing_account(pcv, dimension_balance, dimensions):
 @frappe.whitelist()
 def schedule_next_date(docname: str):
 	timeout = frappe.db.get_single_value("Accounts Settings", "pcv_job_timeout") or 3600
-
 	ppcvd = qb.DocType("Process Period Closing Voucher Detail")
+
 	if to_process := (
 		qb.from_(ppcvd)
-		.select(ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
+		.select(ppcvd.name, ppcvd.processing_date, ppcvd.report_type, ppcvd.parentfield)
 		.where(ppcvd.parent.eq(docname) & ppcvd.status.eq("Queued"))
 		.orderby(ppcvd.parentfield, ppcvd.idx, ppcvd.processing_date)
 		.limit(1)
@@ -264,15 +269,15 @@ def schedule_next_date(docname: str):
 		if not is_scheduler_inactive():
 			frappe.db.set_value(
 				"Process Period Closing Voucher Detail",
-				{
-					"processing_date": to_process[0].processing_date,
-					"parent": docname,
-					"report_type": to_process[0].report_type,
-					"parentfield": to_process[0].parentfield,
-				},
+				to_process[0].name,
 				"status",
 				"Running",
 			)
+			# keep transaction on PPCV and PPCVD short
+			# prevents concurrency errors - REPEATABLE READ
+			if not frappe.in_test:
+				frappe.db.commit()  # nosemgrep
+
 			frappe.enqueue(
 				method="erpnext.accounts.doctype.process_period_closing_voucher.process_period_closing_voucher.process_individual_date",
 				queue="long",
@@ -280,6 +285,7 @@ def schedule_next_date(docname: str):
 				is_async=True,
 				enqueue_after_commit=True,
 				docname=docname,
+				row_name=to_process[0].name,
 				date=to_process[0].processing_date,
 				report_type=to_process[0].report_type,
 				parentfield=to_process[0].parentfield,
@@ -444,6 +450,11 @@ def summarize_and_post_ledger_entries(docname):
 
 	make_closing_entries(closing_entries, pcv.name, pcv.company, pcv.period_end_date)
 
+	# keep transaction on PPCV and PPCVD short
+	# prevents concurrency errors - REPEATABLE READ
+	if not frappe.in_test:
+		frappe.db.commit()  # nosemgrep
+
 	frappe.db.set_value("Period Closing Voucher", pcv.name, "gle_processing_status", "Completed")
 	frappe.db.set_value("Process Period Closing Voucher", docname, "status", "Completed")
 
@@ -529,10 +540,10 @@ def build_dimension_wise_balance_dict(gl_entries):
 	return dimension_balances
 
 
-def process_individual_date(docname: str, date, report_type, parentfield):
+def process_individual_date(docname: str, row_name, date, report_type, parentfield):
 	current_date_status = frappe.db.get_value(
 		"Process Period Closing Voucher Detail",
-		{"processing_date": date, "report_type": report_type, "parentfield": parentfield},
+		row_name,
 		"status",
 	)
 	if current_date_status != "Running":
@@ -579,17 +590,20 @@ def process_individual_date(docname: str, date, report_type, parentfield):
 	# save results
 	frappe.db.set_value(
 		"Process Period Closing Voucher Detail",
-		{"processing_date": date, "parent": docname, "report_type": report_type, "parentfield": parentfield},
+		row_name,
 		"closing_balance",
 		frappe.json.dumps(res),
 	)
 
 	frappe.db.set_value(
 		"Process Period Closing Voucher Detail",
-		{"processing_date": date, "parent": docname, "report_type": report_type, "parentfield": parentfield},
+		row_name,
 		"status",
 		"Completed",
 	)
+	# commit heavy computation before touching PPCV or PPCVD
+	if not frappe.in_test:
+		frappe.db.commit()  # nosemgrep
 
 	# chain call
 	schedule_next_date(docname)

erpnext/accounts/doctype/process_period_closing_voucher/test_process_period_closing_voucher.py

@@ -48,18 +48,27 @@ class TestProcessPeriodClosingVoucher(ERPNextTestSuite):
 		ppcv.save()
 		return ppcv
 
-	def set_processing_date_status(self, date, ppcv, rpt_type, parentfield, status):
+	def set_processing_date_status(self, row_name, status):
 		frappe.db.set_value(
 			"Process Period Closing Voucher Detail",
-			{"processing_date": date, "parent": ppcv, "report_type": rpt_type, "parentfield": parentfield},
+			row_name,
 			"status",
 			status,
 		)
 
-	def get_processing_date_closing_balance(self, date, ppcv, rpt_type, parentfield):
+	def get_row_name(self, ppcv_name, rpt_type, parentfield):
+		return frappe.db.get_all(
+			"Process Period Closing Voucher Detail",
+			filters={"parent": ppcv_name, "report_type": rpt_type, "parentfield": parentfield},
+			order_by="report_type, idx",
+			pluck="name",
+			limit=1,
+		)[0]
+
+	def get_processing_date_closing_balance(self, row_name):
 		return frappe.db.get_value(
 			"Process Period Closing Voucher Detail",
-			{"processing_date": date, "parent": ppcv, "report_type": rpt_type, "parentfield": parentfield},
+			row_name,
 			"closing_balance",
 		)
 
@@ -97,11 +106,10 @@ class TestProcessPeriodClosingVoucher(ERPNextTestSuite):
 		parentfield = "normal_balances"
 		rpt_type = "Profit and Loss"
 		# status has to be set to 'Running' for logic to run
-		self.set_processing_date_status(today(), ppcv.name, rpt_type, parentfield, "Running")
-		process_individual_date(ppcv.name, today(), rpt_type, parentfield)
-		bal = frappe.parse_json(
-			self.get_processing_date_closing_balance(today(), ppcv.name, rpt_type, parentfield)
-		)
+		row_name = self.get_row_name(ppcv.name, rpt_type, parentfield)
+		self.set_processing_date_status(row_name, "Running")
+		process_individual_date(ppcv.name, row_name, today(), rpt_type, parentfield)
+		bal = frappe.parse_json(self.get_processing_date_closing_balance(row_name))
 		self.assertEqual(len(bal), 1)
 		expected_pl = {
 			"account": "Sales - _TC",
@@ -117,11 +125,10 @@ class TestProcessPeriodClosingVoucher(ERPNextTestSuite):
 
 		# Balance sheet balance
 		rpt_type = "Balance Sheet"
-		self.set_processing_date_status(today(), ppcv.name, rpt_type, parentfield, "Running")
-		process_individual_date(ppcv.name, today(), rpt_type, parentfield)
-		bal = frappe.parse_json(
-			self.get_processing_date_closing_balance(today(), ppcv.name, rpt_type, parentfield)
-		)
+		row_name = self.get_row_name(ppcv.name, rpt_type, parentfield)
+		self.set_processing_date_status(row_name, "Running")
+		process_individual_date(ppcv.name, row_name, today(), rpt_type, parentfield)
+		bal = frappe.parse_json(self.get_processing_date_closing_balance(row_name))
 		self.assertEqual(len(bal), 1)
 		expected_bs = {
 			"account": "Debtors - _TC",
@@ -138,11 +145,10 @@ class TestProcessPeriodClosingVoucher(ERPNextTestSuite):
 		# Opening balance
 		parentfield = "z_opening_balances"
 		rpt_type = "Balance Sheet"
-		self.set_processing_date_status(today(), ppcv.name, rpt_type, parentfield, "Running")
-		process_individual_date(ppcv.name, today(), rpt_type, parentfield)
-		bal = frappe.parse_json(
-			self.get_processing_date_closing_balance(today(), ppcv.name, rpt_type, parentfield)
-		)
+		row_name = self.get_row_name(ppcv.name, rpt_type, parentfield)
+		self.set_processing_date_status(row_name, "Running")
+		process_individual_date(ppcv.name, row_name, today(), rpt_type, parentfield)
+		bal = frappe.parse_json(self.get_processing_date_closing_balance(row_name))
 		self.assertEqual(len(bal), 2)
 		opening_cash = next(x for x in bal if x["account"] == "Cash - _TC")
 		expected_opening_cash = {

erpnext/accounts/doctype/process_period_closing_voucher_detail/process_period_closing_voucher_detail.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2025, Frappe Technologies Pvt. Ltd. and contributors
 # For license information, please see license.txt
 
-# import frappe
+import frappe
 from frappe.model.document import Document
 
 
@@ -24,3 +24,10 @@ class ProcessPeriodClosingVoucherDetail(Document):
 	# end: auto-generated types
 
 	pass
+
+
+def on_doctype_update():
+	frappe.db.add_index(
+		"Process Period Closing Voucher Detail",
+		["parent", "status", "parentfield", "idx", "processing_date"],
+	)

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html

@@ -13,7 +13,7 @@
 		</div>
 		{% endif %}
 	</div>
-	<h2 class="text-center">{{ _("GENERAL LEDGER") }}</h2>
+	<h2 class="text-center">{{ _("STATEMENT OF ACCOUNTS") }}</h2>
 	<div>
 		{% if filters.party[0] == filters.party_name[0] %}
 			<h5 style="float: left;">{{ _("Customer: ") }} <b>{{ filters.party_name[0] }}</b></h5>

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -416,7 +416,6 @@ def get_context(customer, doc):
 	return {
 		"doc": template_doc,
 		"customer": frappe.get_doc("Customer", customer),
-		"frappe": frappe.utils,
 	}
 
 
@@ -466,6 +465,8 @@ def get_customer_emails(customer_name, primary_mandatory, billing_and_primary=Tr
 	when Is Billing Contact checked
 	and Primary email- email with Is Primary checked"""
 
+	frappe.has_permission("Customer", "read", customer_name, throw=True)
+
 	billing_email = frappe.db.sql(
 		"""
 		SELECT
@@ -509,6 +510,7 @@ def get_customer_emails(customer_name, primary_mandatory, billing_and_primary=Tr
 @frappe.whitelist()
 def download_statements(document_name):
 	doc = frappe.get_doc("Process Statement Of Accounts", document_name)
+	doc.check_permission("read")
 	report = get_report_pdf(doc)
 	if report:
 		frappe.local.response.filename = doc.name + ".pdf"

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -1388,8 +1388,10 @@
    "fetch_from": "supplier.represents_company",
    "fieldname": "represents_company",
    "fieldtype": "Link",
+   "ignore_user_permissions": 1,
    "label": "Represents Company",
-   "options": "Company"
+   "options": "Company",
+   "read_only": 1
   },
   {
    "depends_on": "eval:doc.update_stock && doc.is_internal_supplier",
@@ -1700,7 +1702,7 @@
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2026-06-13 18:36:46.704623",
+ "modified": "2026-07-12 23:54:21.263951",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -2928,6 +2928,24 @@ class TestPurchaseInvoice(ERPNextTestSuite, StockTestMixin):
 		# Test 4 - Since this PI is overbilled by 130% and only 120% is allowed, it will fail
 		self.assertRaises(frappe.ValidationError, pi.submit)
 
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"over_billing_allowance": 0})
+	def test_non_stock_item_over_billing_against_po_is_blocked(self):
+		service_item = create_item(
+			"_Test Service Item Non Stock PI",
+			is_stock_item=0,
+			is_purchase_item=1,
+		).name
+
+		po = create_purchase_order(item_code=service_item, qty=5, rate=100, do_not_save=False)
+		po.submit()
+
+		pi = make_pi_from_po(po.name)
+		pi.items[0].qty = 10  # overbill by 100 %
+		pi.save()
+
+		with self.assertRaises(frappe.ValidationError):
+			pi.submit()
+
 	def test_discount_percentage_not_set_when_amount_is_manually_set(self):
 		pi = make_purchase_invoice(do_not_save=True)
 		discount_amount = 7

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -2150,11 +2150,14 @@ class TestSalesInvoice(ERPNextTestSuite):
 	def test_create_so_with_margin(self):
 		si = create_sales_invoice(item_code="_Test Item", qty=1, do_not_submit=True)
 		price_list_rate = flt(100) * flt(si.plc_conversion_rate)
+
 		si.items[0].price_list_rate = price_list_rate
 		si.items[0].margin_type = "Percentage"
 		si.items[0].margin_rate_or_amount = 25
 		si.items[0].discount_amount = 0.0
 		si.items[0].discount_percentage = 0.0
+		# set rate to zero, so that it is recalculated on save
+		si.items[0].rate = 0
 		si.save()
 		self.assertEqual(si.get("items")[0].rate, flt((price_list_rate * 25) / 100 + price_list_rate))
 
@@ -3865,6 +3868,51 @@ class TestSalesInvoice(ERPNextTestSuite):
 		self.assertTrue("cannot overbill" in str(err.exception).lower())
 		dn.cancel()
 
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"over_billing_allowance": 0})
+	def test_non_stock_item_over_billing_against_so_is_blocked(self):
+		from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice as make_si_from_so
+		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+
+		service_item = create_item(
+			"_Test Service Item Non Stock SI",
+			is_stock_item=0,
+		).name
+
+		so = make_sales_order(item_code=service_item, qty=5, rate=100)
+		so.submit()
+
+		si = make_si_from_so(so.name)
+		si.items[0].qty = 10  # overbill by 100 %
+		si.save()
+
+		with self.assertRaises(frappe.ValidationError):
+			si.submit()
+
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"over_billing_allowance": 0})
+	def test_non_stock_item_over_billing_against_so_from_quotation_is_blocked(self):
+		from erpnext.selling.doctype.quotation.quotation import make_sales_order as make_so_from_quotation
+		from erpnext.selling.doctype.quotation.test_quotation import make_quotation
+		from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice as make_si_from_so
+
+		service_item = create_item(
+			"_Test Service Item Non Stock SI Quot",
+			is_stock_item=0,
+		).name
+
+		quotation = make_quotation(item_code=service_item, qty=5, rate=100)
+
+		so = make_so_from_quotation(quotation.name)
+		so.delivery_date = frappe.utils.add_days(frappe.utils.today(), 7)
+		so.insert()
+		so.submit()
+
+		si = make_si_from_so(so.name)
+		si.items[0].qty = 10  # overbill by 100 %
+		si.save()
+
+		with self.assertRaises(frappe.ValidationError):
+			si.submit()
+
 	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{

erpnext/accounts/general_ledger.py

@@ -716,13 +716,15 @@ def make_reverse_gl_entries(
 			partial_cancel=partial_cancel,
 		)
 		validate_accounting_period(gl_entries)
-		check_freezing_date(gl_entries[0]["posting_date"], gl_entries[0]["company"], adv_adj)
 
 		is_opening = any(d.get("is_opening") == "Yes" for d in gl_entries)
 
-		# For reverse entries, use the posting_date parameter if provided and valid
-		# Otherwise fall back to original posting_date
-		validation_date = posting_date if posting_date else gl_entries[0]["posting_date"]
+		if immutable_ledger_enabled:
+			validation_date = posting_date or frappe.form_dict.get("posting_date") or getdate()
+		else:
+			validation_date = posting_date if posting_date else gl_entries[0]["posting_date"]
+
+		check_freezing_date(validation_date, gl_entries[0]["company"], adv_adj)
 		validate_against_pcv(is_opening, validation_date, gl_entries[0]["company"])
 
 		if partial_cancel:
@@ -789,7 +791,7 @@ def make_reverse_gl_entries(
 
 			if immutable_ledger_enabled:
 				new_gle["is_cancelled"] = 0
-				new_gle["posting_date"] = frappe.form_dict.get("posting_date") or getdate()
+				new_gle["posting_date"] = posting_date or frappe.form_dict.get("posting_date") or getdate()
 			elif posting_date:
 				new_gle["posting_date"] = posting_date
 

erpnext/accounts/letter_head/company_letterhead/company_letterhead.json

@@ -0,0 +1,26 @@
+{
+ "align": "Left",
+ "content": "<table class=\"invoice-header\">\n\t<tbody>\n\t\t<tr>\n\t\t\t<td class=\"logo-cell\" style=\"vertical-align:middle ! important\">\n\t\t\t\t<div class=\"logo-container\">\n\t\t\t\t\t{% set company_logo = frappe.db.get_value(\"Company\", doc.company, \"company_logo\") if doc.get(\"company\") else None %} {% if\n\t\t\t\t\tcompany_logo %}\n\t\t\t\t\t<img src=\"{{ frappe.utils.get_url(company_logo) }}\" alt=\"Company Logo\">\n\t\t\t\t\t{% endif %}\n\t\t\t\t</div>\n\t\t\t</td>\n\n\t\t\t<td class=\"company-details\">\n\t\t\t\t{% if doc.company %}<div class=\"company-name\">{{ doc.company }}</div>{% endif %}\n\t\t\t\t{% if doc.company_address %} {% set company_address = frappe.db.get_value(\"Address\",\n\t\t\t\tdoc.company_address, [\"address_line1\", \"address_line2\", \"city\", \"state\", \"pincode\",\n\t\t\t\t\"country\"], as_dict=True) %} {% elif doc.billing_address %} {% set company_address =\n\t\t\t\tfrappe.db.get_value(\"Address\", doc.billing_address, [\"address_line1\", \"address_line2\", \"city\",\n\t\t\t\t\"state\", \"pincode\", \"country\"], as_dict=True) %} {% endif %} {% if company_address %} {{\n\t\t\t\tcompany_address.address_line1 or \"\" }}<br>\n\t\t\t\t{% if company_address.address_line2 %} {{ company_address.address_line2 }}<br>\n\t\t\t\t{% endif %} {{ company_address.city or \"\" }}, {{ company_address.state or \"\" }} {{\n\t\t\t\tcompany_address.pincode or \"\" }}, {{ company_address.country or \"\"}}<br>\n\t\t\t\t{% endif %}\n\t\t\t</td>\n\n\t\t\t<td class=\"invoice-info-cell\">\n\t\t\t\t{% set website = frappe.db.get_value(\"Company\", doc.company, \"website\") if doc.get(\"company\") else None %} {% set email =\n\t\t\t\tfrappe.db.get_value(\"Company\", doc.company, \"email\") if doc.get(\"company\") else None %} {% set phone_no =\n\t\t\t\tfrappe.db.get_value(\"Company\", doc.company, \"phone_no\") if doc.get(\"company\") else None %}\n\n\t\t\t\t<div class=\"invoice-info\">\n\t\t\t\t\t<span class=\"invoice-label\">{{ doc.doctype }}</span>\n\t\t\t\t\t<span>{{ doc.name }}</span>\n\t\t\t\t</div>\n\t\t\t\t{% if website %}\n\t\t\t\t<div class=\"invoice-info\">\n\t\t\t\t\t<span class=\"invoice-label\">{{ _(\"Website:\") }}</span>\n\t\t\t\t\t<span>{{ website }}</span>\n\t\t\t\t</div>\n\t\t\t\t{% endif %} {% if email %}\n\t\t\t\t<div class=\"invoice-info\">\n\t\t\t\t\t<span class=\"invoice-label\">{{ _(\"Email:\") }}</span>\n\t\t\t\t\t<span>{{ email }}</span>\n\t\t\t\t</div>\n\t\t\t\t{% endif %} {% if phone_no %}\n\t\t\t\t<div class=\"invoice-info\">\n\t\t\t\t\t<span class=\"invoice-label\">{{ _(\"Contact:\") }}</span>\n\t\t\t\t\t<span>{{ phone_no }}</span>\n\t\t\t\t</div>\n\t\t\t\t{% endif %}\n\t\t\t</td>\n\t\t</tr>\n\t</tbody>\n</table>",
+ "creation": "2026-05-15 15:21:48.255627",
+ "custom_css": "\t.letter-head {\n\t\tborder-radius: 18px;\n\t\tpadding-right: 12px;\n\t\tmargin-left: 12px;\n\t\tmargin-right: 12px;\n\t}\n\n\t.letter-head td {\n\t\tpadding: 0px !important;\n\t}\n\t.invoice-header {\n\t\twidth: 100%;\n\t}\n\t.logo-cell {\n\t\twidth: 100px;\n\t\ttext-align: center;\n\t\tposition: relative;\n\t}\n\t.logo-container {\n\t\twidth: 90px;\n\t\tdisplay: block;\n\t}\n\t.logo-container img {\n\t\tmax-width: 90px;\n\t\tmax-height: 90px;\n\t\tdisplay: inline-block;\n\t\tborder-radius: 15px;\n\t}\n\t.company-details {\n\t\twidth: 40%;\n\t\talign-content: center;\n\t}\n\t.company-name {\n\t\tfont-size: 14px;\n\t\tfont-weight: bold;\n\t\tcolor: #171717;\n\t\tmargin-bottom: 4px;\n\t}\n\t.invoice-info-cell {\n\t\tfloat: right;\n\t\tvertical-align: top;\n\t}\n\t.invoice-info {\n\t\tmargin-bottom: 2px;\n\t}\n\t.invoice-label {\n\t\tcolor: #7c7c7c;\n\t\tdisplay: inline-block;\n\t\tmargin-right: 5px;\n\t}",
+ "disabled": 0,
+ "docstatus": 0,
+ "doctype": "Letter Head",
+ "footer_align": "Left",
+ "footer_image_height": 0.0,
+ "footer_image_width": 0.0,
+ "footer_source": "Image",
+ "idx": 0,
+ "image_height": 0.0,
+ "image_width": 0.0,
+ "is_default": 0,
+ "letter_head_for": "DocType",
+ "letter_head_name": "Company Letterhead",
+ "modified": "2026-07-12 21:11:44.765083",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Company Letterhead",
+ "owner": "Administrator",
+ "source": "HTML",
+ "standard": "Yes"
+}

erpnext/accounts/letter_head/company_letterhead___grey/company_letterhead___grey.json

@@ -0,0 +1,26 @@
+{
+ "align": "Left",
+ "content": "<table class=\"letterhead-container\" style=\"width:100%\">\n\t<tbody>\n\t\t<tr>\n\t\t\t<td class=\"logo-address\">\n\t\t\t\t{% set company_logo = frappe.db.get_value(\"Company\", doc.company, \"company_logo\") if doc.get(\"company\") else None %} {% if\n\t\t\t\tcompany_logo %}\n\t\t\t\t<div class=\"logo\">\n\t\t\t\t\t<img src=\"{{ frappe.utils.get_url(company_logo) }}\" style=\"width:200px\">\n\t\t\t\t</div>\n\t\t\t\t{% endif %}\n\t\t\t\t{% if doc.company %}<div class=\"company-name\">{{ doc.company }}</div>{% endif %}\n\t\t\t\t<div class=\"company-address\">\n\t\t\t\t\t{% if doc.company_address %} {% set company_address = frappe.db.get_value(\"Address\",\n\t\t\t\t\tdoc.company_address, [\"address_line1\", \"address_line2\", \"city\", \"state\", \"pincode\",\n\t\t\t\t\t\"country\"], as_dict=True) %} {% elif doc.billing_address %} {% set company_address =\n\t\t\t\t\tfrappe.db.get_value(\"Address\", doc.billing_address, [\"address_line1\", \"address_line2\",\n\t\t\t\t\t\"city\", \"state\", \"pincode\", \"country\"], as_dict=True) %} {% endif %} {% if company_address\n\t\t\t\t\t%} {{ company_address.address_line1 or \"\" }}<br>\n\t\t\t\t\t{% if company_address.address_line2 %} {{ company_address.address_line2 }}<br>\n\t\t\t\t\t{% endif %} {{ company_address.city or \"\" }}, {{ company_address.state or \"\" }} {{\n\t\t\t\t\tcompany_address.pincode or \"\" }}, {{ company_address.country or \"\"}}<br>\n\t\t\t\t\t{% endif %}\n\t\t\t\t</div>\n\t\t\t</td>\n\n\t\t\t<td style=\"vertical-align:top\">\n\t\t\t\t<div style=\"height:90px;margin-bottom:10px;text-align:right\">\n\t\t\t\t\t<div class=\"invoice-title\">{{ doc.doctype }}</div>\n\t\t\t\t\t<div class=\"invoice-number\">{{ doc.name }}</div>\n\t\t\t\t\t<br>\n\t\t\t\t</div>\n\t\t\t\t<div style=\"text-align:left;float:right\" class=\"other-details\">\n\t\t\t\t\t{% if doc.company %}{% set company_details = frappe.db.get_value(\"Company\", doc.company, [\"website\", \"email\",\n\t\t\t\t\t\"phone_no\"], as_dict=True) %}{% set website = company_details.website %}{% set email =\n\t\t\t\t\tcompany_details.email %}{% set phone_no = company_details.phone_no %}{% else %}{% set website = None %}{% set email = None %}{% set phone_no = None %}{% endif %} {% if website %}\n\t\t\t\t\t<div>\n\t\t\t\t\t\t<span class=\"contact-title\">{{ _(\"Website:\") }}</span><span class=\"contact-value\">{{ website }}</span>\n\t\t\t\t\t</div>\n\t\t\t\t\t{% endif %} {% if email %}\n\t\t\t\t\t<div>\n\t\t\t\t\t\t<span class=\"contact-title\">{{ _(\"Email:\") }}</span><span class=\"contact-value\">{{ email }}</span>\n\t\t\t\t\t</div>\n\t\t\t\t\t{% endif %} {% if phone_no %}\n\t\t\t\t\t<div>\n\t\t\t\t\t\t<span class=\"contact-title\">{{ _(\"Contact:\") }}</span><span class=\"contact-value\">{{ phone_no }}</span>\n\t\t\t\t\t</div>\n\t\t\t\t\t{% endif %}\n\t\t\t\t</div>\n\t\t\t</td>\n\t\t</tr>\n\t</tbody>\n</table>\n",
+ "creation": "2026-05-15 15:21:48.373815",
+ "custom_css": "\t.print-format-preview {\n\t\tmargin-top: 12px;\n\t}\n\t.letter-head {\n\t\tborder-radius: 18px;\n\t\tbackground: #f8f8f8;\n\t\tpadding: 12px;\n\t\tmargin-left: 12px;\n\t\tmargin-right: 12px;\n\t}\n\t.letterhead-container {\n\t\twidth: 100%;\n\t}\n\t.letterhead-container .other-details {\n\t\tposition: absolute;\n\t\tright: 0;\n\t\tbottom: 0;\n\t}\n\t.logo-address {\n\t\twidth: 65%;\n\t\tvertical-align: top;\n\t}\n\n\t.letter-head .logo {\n\t\twidth: 90px;\n\t\tdisplay: block;\n\t\tmargin-bottom: 10px;\n\t}\n\n\t.letter-head .logo img {\n\t\tborder-radius: 15px;\n\t}\n\n\t.company-name {\n\t\tcolor: #171717;\n\t\tfont-weight: bold;\n\t\tline-height: 23px;\n\t\tmargin-bottom: 5px;\n\t}\n\n\t.company-address {\n\t\tcolor: #171717;\n\t\twidth: 300px;\n\t}\n\n\t.invoice-title {\n\t\tfont-weight: bold;\n\t}\n\n\t.invoice-number {\n\t\tcolor: #7c7c7c;\n\t}\n\n\t.contact-title {\n\t\tcolor: #7c7c7c;\n\t\twidth: 60px;\n\t\tdisplay: inline-block;\n\t\tvertical-align: top;\n\t\tmargin-right: 10px;\n\t}\n\n\t.contact-value {\n\t\tcolor: #171717;\n\t\tdisplay: inline-block;\n\t}\n\t.letterhead-container td {\n\t\tpadding: 0px !important;\n\t\tposition: relative;\n\t}",
+ "disabled": 0,
+ "docstatus": 0,
+ "doctype": "Letter Head",
+ "footer_align": "Left",
+ "footer_image_height": 0.0,
+ "footer_image_width": 0.0,
+ "footer_source": "Image",
+ "idx": 0,
+ "image_height": 0.0,
+ "image_width": 0.0,
+ "is_default": 0,
+ "letter_head_for": "DocType",
+ "letter_head_name": "Company Letterhead - Grey",
+ "modified": "2026-07-12 22:03:24.525672",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Company Letterhead - Grey",
+ "owner": "Administrator",
+ "source": "HTML",
+ "standard": "Yes"
+}

erpnext/accounts/letter_head/company_letterhead_report/company_letterhead_report.json

@@ -0,0 +1,26 @@
+{
+ "align": "Left",
+ "content": "<table class=\"invoice-header\">\n\t<tbody>\n\t\t<tr>\n\n\t\t\t<td class=\"logo-cell\" style=\"vertical-align:top\">\n\t\t\t\t{% if doc.company %}{% set company = frappe.get_doc(\"Company\", doc.company) %}{% else %}{% set company = frappe._dict() %}{% endif %}\n\n\t\t\t\t<div class=\"logo-container\">\n\t\t\t\t\t{% if company.company_logo %}\n\t\t\t\t\t<img src=\"{{ frappe.utils.get_url(company.company_logo) }}\" alt=\"Company Logo\">\n\t\t\t\t\t{% endif %}\n\t\t\t\t</div>\n\t\t\t</td>\n\n\t\t\t<td class=\"company-details\" style=\"vertical-align:top\">\n\t\t\t\t{% if company.name %}<div class=\"company-name\">{{ company.name }}</div>{% endif %}\n\n\t\t\t\t{% set company_address_name = frappe.db.get_value(\n\t\t\t\t\t\"Dynamic Link\",\n\t\t\t\t\t{\n\t\t\t\t\t\t\"link_doctype\": \"Company\",\n\t\t\t\t\t\t\"link_name\": company.name,\n\t\t\t\t\t\t\"parenttype\": \"Address\"\n\t\t\t\t\t},\n\t\t\t\t\t\"parent\"\n\t\t\t\t) %}\n\n\t\t\t\t{% if company_address_name %}\n\t\t\t\t\t{% set company_address = frappe.db.get_value(\n\t\t\t\t\t\t\"Address\",\n\t\t\t\t\t\tcompany_address_name,\n\t\t\t\t\t\t[\"address_line1\", \"address_line2\", \"city\", \"state\", \"pincode\", \"country\"],\n\t\t\t\t\t\tas_dict=True\n\t\t\t\t\t) %}\n\t\t\t\t{% endif %}\n\n\t\t\t\t{% if company_address %}\n\t\t\t\t<div class=\"company-address\">\n\t\t\t\t\t{{ company_address.address_line1 or \"\" }}\n\n\t\t\t\t\t{% if company_address.address_line2 %}\n\t\t\t\t\t\t<br>{{ company_address.address_line2 }}\n\t\t\t\t\t{% endif %}\n\n\t\t\t\t\t<br>\n\n\t\t\t\t\t{{ company_address.city or \"\" }}\n\t\t\t\t\t{% if company_address.state %}, {{ company_address.state }}{% endif %}\n\t\t\t\t\t{{ company_address.pincode or \"\" }}\n\n\t\t\t\t\t{% if company_address.country %}\n\t\t\t\t\t\t, {{ company_address.country }}\n\t\t\t\t\t{% endif %}\n\t\t\t\t</div>\n\t\t\t\t{% endif %}\n\t\t\t</td>\n\n\t\t\t<td class=\"invoice-info-cell\" style=\"vertical-align:top;text-align:right\">\n\n\t\t\t\t{% set website = frappe.db.get_value(\"Company\", doc.company, \"website\") %}\n\t\t\t\t{% set email = frappe.db.get_value(\"Company\", doc.company, \"email\") %}\n\t\t\t\t{% set phone_no = frappe.db.get_value(\"Company\", doc.company, \"phone_no\") %}\n\n\t\t\t\t{% if website %}\n\t\t\t\t<div class=\"invoice-info\">\n\t\t\t\t\t<span class=\"invoice-label\">{{ _(\"Website:\") }}</span>\n\t\t\t\t\t<span>{{ website }}</span>\n\t\t\t\t</div>\n\t\t\t\t{% endif %}\n\n\t\t\t\t{% if email %}\n\t\t\t\t<div class=\"invoice-info\">\n\t\t\t\t\t<span class=\"invoice-label\">{{ _(\"Email:\") }}</span>\n\t\t\t\t\t<span>{{ email }}</span>\n\t\t\t\t</div>\n\t\t\t\t{% endif %}\n\n\t\t\t\t{% if phone_no %}\n\t\t\t\t<div class=\"invoice-info\">\n\t\t\t\t\t<span class=\"invoice-label\">{{ _(\"Contact:\") }}</span>\n\t\t\t\t\t<span>{{ phone_no }}</span>\n\t\t\t\t</div>\n\t\t\t\t{% endif %}\n\t\t\t</td>\n\n\t\t</tr>\n\t</tbody>\n</table>",
+ "creation": "2026-05-15 19:49:47.582252",
+ "custom_css": ".letter-head {\n\tborder-radius: 18px;\n\tpadding: 8px 10px;\n\tmargin: 10px 0 14px;\n\tfont-family: Inter, sans-serif;\n\tfont-size: 14px;\n\tcolor: #171717;\n}\n\n.letter-head td {\n\tpadding: 0 !important;\n\tvertical-align: middle;\n}\n\n.invoice-header {\n\twidth: 100%;\n\tborder-collapse: collapse;\n\ttable-layout: fixed;\n\tborder-bottom: 1px solid #ededed;\n\tpadding-bottom: 10px;\n}\n\n.logo-cell {\n\twidth: 100px;\n\ttext-align: center;\n\twhite-space: nowrap;\n}\n\n.logo-container {\n\tdisplay: inline-block;\n\tmargin: auto;\n}\n\n.logo-container img {\n\tmax-width: 95px;\n\tmax-height: 95px;\n\tdisplay: block;\n\tborder-radius: 12px;\n}\n\n.company-details {\n\twidth: 55%;\n\tpadding-left: 10px !important;\n\tline-height: 1.5;\n}\n\n.company-name {\n\tfont-size: 14px;\n\tfont-weight: 600;\n\tcolor: #171717;\n\tmargin-bottom: 4px;\n}\n\n.company-address {\n\tfont-size: 14px;\n\tline-height: 1.5;\n\tcolor: #171717;\n}\n\n.invoice-info-cell {\n\twidth: 240px;\n\ttext-align: right;\n\tvertical-align: top !important;\n\tline-height: 1.5;\n}\n\n.document-name {\n\tfont-size: 14px;\n\tfont-weight: 600;\n\tcolor: #171717;\n\tmargin-bottom: 6px;\n}\n\n.invoice-info {\n\tfont-size: 14px;\n\tcolor: #171717;\n\tmargin-bottom: 2px;\n\tfont-variant-numeric: tabular-nums;\n}\n\n.invoice-label {\n\tcolor: #7c7c7c;\n\tfont-weight: 500;\n\tmargin-right: 4px;\n\tdisplay: inline-block;\n}",
+ "disabled": 0,
+ "docstatus": 0,
+ "doctype": "Letter Head",
+ "footer_align": "Left",
+ "footer_image_height": 0.0,
+ "footer_image_width": 0.0,
+ "footer_source": "Image",
+ "idx": 0,
+ "image_height": 0.0,
+ "image_width": 0.0,
+ "is_default": 0,
+ "letter_head_for": "Report",
+ "letter_head_name": "Company Letterhead Report",
+ "modified": "2026-06-24 18:06:39.820968",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Company Letterhead Report",
+ "owner": "Administrator",
+ "source": "HTML",
+ "standard": "Yes"
+}

erpnext/accounts/party.py

@@ -428,6 +428,17 @@ def get_party_account(party_type, party=None, company=None, include_advance=Fals
 	Will first search in party (Customer / Supplier) record, if not found,
 	will search in group (Customer Group / Supplier Group),
 	finally will return default."""
+
+	def account_perm_check(account):
+		ptype = "select" if frappe.only_has_select_perm("Account") else "read"
+		if frappe.has_permission("Account", ptype, account):
+			return
+
+		# Using custom message to prevent data leak in case of `apply_strict_permission` is enabled.
+		frappe.throw(
+			_("User don't have permissions to select/read this account."), exc=frappe.PermissionError
+		)
+
 	if not party_type:
 		frappe.throw(_("Party Type is mandatory"))
 	if not company:
@@ -438,46 +449,51 @@ def get_party_account(party_type, party=None, company=None, include_advance=Fals
 			"default_receivable_account" if party_type == "Customer" else "default_payable_account"
 		)
 
-		return frappe.get_cached_value("Company", company, default_account_name)
-
-	account = frappe.db.get_value(
-		"Party Account", {"parenttype": party_type, "parent": party, "company": company}, "account"
-	)
-
-	if not account and party_type in ["Customer", "Supplier"]:
-		party_group_doctype = "Customer Group" if party_type == "Customer" else "Supplier Group"
-		group = frappe.get_cached_value(party_type, party, scrub(party_group_doctype))
+		account = frappe.get_cached_value("Company", company, default_account_name)
+	else:
 		account = frappe.db.get_value(
-			"Party Account",
-			{"parenttype": party_group_doctype, "parent": group, "company": company},
-			"account",
+			"Party Account", {"parenttype": party_type, "parent": party, "company": company}, "account"
 		)
 
-	if not account and party_type in ["Customer", "Supplier"]:
-		default_account_name = (
-			"default_receivable_account" if party_type == "Customer" else "default_payable_account"
-		)
-		account = frappe.get_cached_value("Company", company, default_account_name)
+		if not account and party_type in ["Customer", "Supplier"]:
+			party_group_doctype = "Customer Group" if party_type == "Customer" else "Supplier Group"
+			group = frappe.get_cached_value(party_type, party, scrub(party_group_doctype))
+			account = frappe.db.get_value(
+				"Party Account",
+				{"parenttype": party_group_doctype, "parent": group, "company": company},
+				"account",
+			)
 
-	existing_gle_currency = get_party_gle_currency(party_type, party, company)
-	if existing_gle_currency:
-		if account:
-			account_currency = frappe.get_cached_value("Account", account, "account_currency")
-		if (account and account_currency != existing_gle_currency) or not account:
-			account = get_party_gle_account(party_type, party, company)
+		if not account and party_type in ["Customer", "Supplier"]:
+			default_account_name = (
+				"default_receivable_account" if party_type == "Customer" else "default_payable_account"
+			)
+			account = frappe.get_cached_value("Company", company, default_account_name)
 
-	# get default account on the basis of party type
-	if not account:
-		account_type = frappe.get_cached_value("Party Type", party_type, "account_type")
-		default_account_name = "default_" + account_type.lower() + "_account"
-		account = frappe.get_cached_value("Company", company, default_account_name)
+		existing_gle_currency = get_party_gle_currency(party_type, party, company)
+		if existing_gle_currency:
+			if account:
+				account_currency = frappe.get_cached_value("Account", account, "account_currency")
+			if (account and account_currency != existing_gle_currency) or not account:
+				account = get_party_gle_account(party_type, party, company)
 
-	if include_advance and party_type in ["Customer", "Supplier", "Student"]:
+		# get default account on the basis of party type
+		if not account:
+			account_type = frappe.get_cached_value("Party Type", party_type, "account_type")
+			default_account_name = "default_" + account_type.lower() + "_account"
+			account = frappe.get_cached_value("Company", company, default_account_name)
+
+	if account:
+		account_perm_check(account)
+
+	if include_advance and party and party_type in ["Customer", "Supplier", "Student"]:
 		advance_account = get_party_advance_account(party_type, party, company)
+
 		if advance_account:
+			account_perm_check(advance_account)
 			return [account, advance_account]
-		else:
-			return [account]
+
+		return [account]
 
 	return account
 
@@ -927,6 +943,15 @@ def get_dashboard_info(party_type, party, loyalty_program=None):
 		if party_type == "Supplier":
 			info["total_unpaid"] = -1 * info["total_unpaid"]
 
+		if info["total_unpaid"] < 0:
+			info["balance_label"] = (
+				"Total Advance Paid" if party_type == "Supplier" else "Total Advance Received"
+			)
+			info["balance_amount"] = abs(info["total_unpaid"])
+		else:
+			info["balance_label"] = "Total Unpaid"
+			info["balance_amount"] = info["total_unpaid"]
+
 		company_wise_info.append(info)
 
 	return company_wise_info

erpnext/accounts/report/accounts_payable/accounts_payable.json

@@ -4,13 +4,20 @@
  "columns": [],
  "creation": "2013-04-22 16:16:03",
  "default_print_format": "Accounts Payable Standard",
+ "disable_prepared_report_automation": 0,
  "disabled": 0,
  "docstatus": 0,
  "doctype": "Report",
+ "doctype_to_sync": [
+  {
+   "doc_type": "Payment Ledger Entry"
+  }
+ ],
  "filters": [],
+ "generate_csv": 0,
  "idx": 3,
  "is_standard": "Yes",
- "modified": "2026-05-22 14:35:14.716933",
+ "modified": "2026-07-01 13:37:41.185347",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Payable",
@@ -33,5 +40,6 @@
    "role": "Auditor"
   }
  ],
+ "snapshot_report": 0,
  "timeout": 0
 }

erpnext/accounts/report/accounts_receivable/accounts_receivable.json

@@ -4,13 +4,20 @@
  "columns": [],
  "creation": "2013-04-16 11:31:13",
  "default_print_format": "Accounts Receivable Standard",
+ "disable_prepared_report_automation": 0,
  "disabled": 0,
  "docstatus": 0,
  "doctype": "Report",
+ "doctype_to_sync": [
+  {
+   "doc_type": "Payment Ledger Entry"
+  }
+ ],
  "filters": [],
+ "generate_csv": 0,
  "idx": 5,
  "is_standard": "Yes",
- "modified": "2026-05-22 14:34:57.666402",
+ "modified": "2026-07-01 13:37:44.167999",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Receivable",
@@ -27,5 +34,6 @@
    "role": "Accounts User"
   }
  ],
+ "snapshot_report": 0,
  "timeout": 0
 }

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -265,10 +265,12 @@ class ReceivablePayableReport:
 
 		# Build and use a separate row for Employee Advances.
 		# This allows Payments or Journals made against Emp Advance to be processed.
-		if (
-			not row
-			and ple.against_voucher_type == "Employee Advance"
-			and self.filters.handle_employee_advances
+		if not row and (
+			(ple.against_voucher_type == "Employee Advance" and self.filters.handle_employee_advances)
+			or (
+				ple.against_voucher_type == "Exchange Rate Revaluation"
+				and self.filters.for_revaluation_journals
+			)
 		):
 			_d = self.build_voucher_dict(ple)
 			_d.voucher_type = ple.against_voucher_type

erpnext/accounts/report/balance_sheet/balance_sheet.json

@@ -4,13 +4,20 @@
  "columns": [],
  "creation": "2014-07-14 05:24:20.385279",
  "default_print_format": "Balance Sheet Standard",
+ "disable_prepared_report_automation": 0,
  "disabled": 0,
  "docstatus": 0,
  "doctype": "Report",
+ "doctype_to_sync": [
+  {
+   "doc_type": "GL Entry"
+  }
+ ],
  "filters": [],
+ "generate_csv": 0,
  "idx": 3,
  "is_standard": "Yes",
- "modified": "2026-05-22 14:35:28.187799",
+ "modified": "2026-06-22 13:38:25.236839",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Balance Sheet",
@@ -30,5 +37,6 @@
    "role": "Auditor"
   }
  ],
+ "synced_report": 0,
  "timeout": 0
 }

erpnext/accounts/report/balance_sheet/balance_sheet.py

@@ -4,18 +4,27 @@
 
 import frappe
 from frappe import _
-from frappe.utils import cint, flt
+from frappe.utils import add_days, cint, flt
 
 from erpnext.accounts.doctype.financial_report_template.financial_report_engine import (
 	FinancialReportEngine,
 	get_xlsx_styles,  #! DO NOT REMOVE - hook for styling
 )
 from erpnext.accounts.report.financial_statements import (
+	accumulate_values_into_parents,
+	add_total_row,
+	calculate_values,
 	compute_growth_view_data,
+	filter_accounts,
+	filter_out_zero_value_rows,
+	get_accounting_entries,
+	get_accounts,
+	get_appropriate_currency,
 	get_columns,
 	get_data,
 	get_filtered_list_for_consolidated_report,
 	get_period_list,
+	prepare_data,
 )
 
 
@@ -266,3 +275,196 @@ def get_chart_data(filters, chart_columns, asset, liability, equity, currency):
 	chart["currency"] = currency
 
 	return chart
+
+
+def execute_snapshot_report(filters):
+	from frappe.database.duckdb.database import get_latest_sync
+
+	if not (conn := get_latest_sync("GL Entry")):
+		frappe.throw(_("Balance Sheet requires {0} to be synced to DuckDB").format(frappe.bold("GL Entry")))
+
+	period_list = get_period_list(
+		filters.from_fiscal_year,
+		filters.to_fiscal_year,
+		filters.period_start_date,
+		filters.period_end_date,
+		filters.filter_based_on,
+		filters.periodicity,
+		company=filters.company,
+	)
+	filters.period_start_date = period_list[0]["year_start_date"]
+
+	currency = filters.presentation_currency or frappe.get_cached_value(
+		"Company", filters.company, "default_currency"
+	)
+
+	asset = _get_data_duckdb(conn, filters, "Asset", "Debit", period_list)
+	liability = _get_data_duckdb(conn, filters, "Liability", "Credit", period_list)
+	equity = _get_data_duckdb(conn, filters, "Equity", "Credit", period_list)
+
+	provisional_profit_loss, total_credit = get_provisional_profit_loss(
+		asset, liability, equity, period_list, filters.company, currency
+	)
+	message, opening_balance = check_opening_balance(asset, liability, equity)
+
+	data = []
+	data.extend(asset or [])
+	data.extend(liability or [])
+	data.extend(equity or [])
+	if opening_balance and round(opening_balance, 2) != 0:
+		unclosed = {
+			"account_name": "'" + _("Unclosed Fiscal Years Profit / Loss (Credit)") + "'",
+			"account": "'" + _("Unclosed Fiscal Years Profit / Loss (Credit)") + "'",
+			"warn_if_negative": True,
+			"currency": currency,
+		}
+		for period in period_list:
+			unclosed[period.key] = opening_balance
+			if provisional_profit_loss:
+				provisional_profit_loss[period.key] = provisional_profit_loss[period.key] - opening_balance
+		unclosed["total"] = opening_balance
+		data.append(unclosed)
+
+	if provisional_profit_loss:
+		data.append(provisional_profit_loss)
+	if total_credit:
+		data.append(total_credit)
+
+	columns = get_columns(
+		filters.periodicity, period_list, filters.accumulated_values, company=filters.company
+	)
+	chart = get_chart_data(filters, period_list, asset, liability, equity, currency)
+	report_summary, primitive_summary = get_report_summary(
+		period_list, asset, liability, equity, provisional_profit_loss, currency, filters
+	)
+
+	if filters.get("selected_view") == "Growth":
+		compute_growth_view_data(data, period_list)
+
+	return columns, data, message, chart, report_summary, primitive_summary
+
+
+def _get_data_duckdb(conn, filters, root_type, balance_must_be, period_list):
+	accounts = get_accounts(filters.company, root_type)
+	if not accounts:
+		return None
+
+	accounts, accounts_by_name, parent_children_map = filter_accounts(accounts)
+	company_currency = get_appropriate_currency(filters.company, filters)
+
+	gl_entries_by_account = {}
+	_load_gl_entries_duckdb(conn, filters, period_list, accounts, gl_entries_by_account, root_type)
+
+	calculate_values(
+		accounts_by_name,
+		gl_entries_by_account,
+		period_list,
+		filters.accumulated_values,
+		False,
+	)
+	accumulate_values_into_parents(accounts, accounts_by_name, period_list)
+
+	out = prepare_data(
+		accounts,
+		balance_must_be,
+		period_list,
+		company_currency,
+		accumulated_values=filters.accumulated_values,
+	)
+	out = filter_out_zero_value_rows(out, parent_children_map, filters.show_zero_values)
+
+	if out:
+		add_total_row(out, root_type, balance_must_be, period_list, company_currency)
+
+	return out
+
+
+def _load_gl_entries_duckdb(conn, filters, period_list, accounts, gl_entries_by_account, root_type):
+	from erpnext.accounts.report.trial_balance.trial_balance import (
+		_extra_gl_conditions,
+		_fetch_gl_rows_duckdb,
+	)
+	from erpnext.accounts.report.utils import convert_to_presentation_currency, get_currency
+
+	company = filters.company
+	year_start_date = period_list[0]["year_start_date"]
+	last_to_date = period_list[-1]["to_date"]
+	ignore_is_opening = frappe.get_single_value("Accounts Settings", "ignore_is_opening_check_for_reporting")
+
+	leaf_accounts = [acc.name for acc in accounts if not acc.is_group]
+	if not leaf_accounts:
+		return
+
+	opening_from_date = None
+	ignore_opening_entries = False
+
+	ignore_closing_balances = frappe.get_single_value("Accounts Settings", "ignore_account_closing_balance")
+	if not ignore_closing_balances:
+		last_pcv_list = frappe.db.get_all(
+			"Period Closing Voucher",
+			filters={
+				"docstatus": 1,
+				"company": company,
+				"period_end_date": ("<", filters.get("period_start_date") or year_start_date),
+			},
+			fields=["period_end_date", "name"],
+			order_by="period_end_date desc",
+			limit=1,
+		)
+		if last_pcv_list:
+			last_pcv = last_pcv_list[0]
+			pcv_entries = get_accounting_entries(
+				"Account Closing Balance",
+				None,
+				last_to_date,
+				filters,
+				root_type=root_type,
+				ignore_closing_entries=False,
+				period_closing_voucher=last_pcv.name,
+			)
+			if filters.get("presentation_currency"):
+				convert_to_presentation_currency(pcv_entries, get_currency(filters))
+			for entry in pcv_entries:
+				gl_entries_by_account.setdefault(entry.account, []).append(entry)
+			opening_from_date = add_days(last_pcv.period_end_date, 1)
+			ignore_opening_entries = True
+
+	extra_cond, extra_params = _extra_gl_conditions(filters)
+	account_placeholders = ", ".join(["?"] * len(leaf_accounts))
+	base_conds = [
+		"company = ?",
+		"is_cancelled = 0",
+		f"account IN ({account_placeholders})",
+	]
+	base_params = [company, *leaf_accounts]
+	if ignore_opening_entries and not ignore_is_opening:
+		base_conds.append("is_opening = 'No'")
+	base_conds.extend(extra_cond)
+	base_params.extend(extra_params)
+
+	# Opening GL entries from DuckDB (entries before year_start_date)
+	open_conds = [*base_conds, "posting_date < ?"]
+	open_params = [*base_params, year_start_date]
+	if opening_from_date:
+		open_conds = [*open_conds, "posting_date >= ?"]
+		open_params = [*open_params, opening_from_date]
+
+	opening_entries = _fetch_gl_rows_duckdb(conn, open_conds, open_params)
+	if filters.get("presentation_currency"):
+		convert_to_presentation_currency(opening_entries, get_currency(filters))
+	synthetic_open_date = add_days(year_start_date, -1)
+	for entry in opening_entries:
+		entry.posting_date = synthetic_open_date
+		gl_entries_by_account.setdefault(entry.account, []).append(entry)
+
+	# Period GL entries from DuckDB (one aggregated query per period)
+	for period in period_list:
+		period_conds = [*base_conds, "posting_date >= ?", "posting_date <= ?"]
+		period_params = [*base_params, period.from_date, period.to_date]
+
+		period_entries = _fetch_gl_rows_duckdb(conn, period_conds, period_params)
+		if filters.get("presentation_currency"):
+			convert_to_presentation_currency(period_entries, get_currency(filters))
+		for entry in period_entries:
+			entry.posting_date = period.to_date
+			gl_entries_by_account.setdefault(entry.account, []).append(entry)

erpnext/accounts/report/budget_variance_report/budget_variance_report.py

@@ -428,6 +428,11 @@ def build_comparison_chart_data(filters, columns, data):
 		if not fieldname:
 			continue
 
+		# skip the dimension column ("budget_against"), it only matches the
+		# "budget_" prefix by coincidence and would shift the actual values by one
+		if fieldname == "budget_against":
+			continue
+
 		if fieldname.startswith("budget_"):
 			budget_fields.append(fieldname)
 		elif fieldname.startswith("actual_"):
@@ -439,7 +444,7 @@ def build_comparison_chart_data(filters, columns, data):
 	labels = [
 		col["label"].replace("Budget", "").strip()
 		for col in columns
-		if col.get("fieldname", "").startswith("budget_")
+		if col.get("fieldname", "").startswith("budget_") and col.get("fieldname") != "budget_against"
 	]
 
 	budget_values = [0] * len(budget_fields)

erpnext/accounts/report/financial_ratios/financial_ratios.py

@@ -76,6 +76,7 @@ def get_ratios_data(filters, period_list, years):
 	cogs, total_expense = {}, {}
 	quick_asset = {}
 	direct_expense = {}
+	fixed_asset = {}
 
 	for year in years:
 		total_quick_asset = 0
@@ -93,6 +94,7 @@ def get_ratios_data(filters, period_list, years):
 				quick_asset,
 				total_quick_asset,
 			],
+			[fixed_asset, total_asset, "Fixed Asset", year, assets, "Asset", {}, 0],
 			[
 				current_liability,
 				total_liability,
@@ -112,7 +114,7 @@ def get_ratios_data(filters, period_list, years):
 	add_solvency_ratios(
 		data, years, total_asset, total_liability, net_sales, cogs, total_income, total_expense
 	)
-	add_turnover_ratios(data, years, period_list, filters, total_asset, net_sales, cogs, direct_expense)
+	add_turnover_ratios(data, years, period_list, filters, fixed_asset, net_sales, cogs, direct_expense)
 
 	return data
 
@@ -193,7 +195,7 @@ def add_solvency_ratios(
 	data.append(return_on_equity_ratio)
 
 
-def add_turnover_ratios(data, years, period_list, filters, total_asset, net_sales, cogs, direct_expense):
+def add_turnover_ratios(data, years, period_list, filters, fixed_asset, net_sales, cogs, direct_expense):
 	precision = frappe.db.get_single_value("System Settings", "float_precision")
 	data.append({"ratio": _("Turnover Ratios")})
 
@@ -208,7 +210,7 @@ def add_turnover_ratios(data, years, period_list, filters, total_asset, net_sale
 	)
 
 	ratio_data = [
-		[_("Fixed Asset Turnover Ratio"), net_sales, total_asset],
+		[_("Fixed Asset Turnover Ratio"), net_sales, fixed_asset],
 		[_("Debtor Turnover Ratio"), net_sales, avg_debtors],
 		[_("Creditor Turnover Ratio"), direct_expense, avg_creditors],
 		[_("Inventory Turnover Ratio"), cogs, avg_stock],

erpnext/accounts/report/financial_ratios/test_financial_ratios.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# MIT License. See license.txt
+
+import frappe
+from frappe.utils import today
+
+from erpnext.accounts.report.financial_ratios.financial_ratios import execute
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestFinancialRatios(ERPNextTestSuite):
+	def setUp(self):
+		self.company = "_Test Company"
+		self.abbr = "_TC"
+		# The report matches the group accounts by their account_type, which the
+		# standard chart of accounts does not set on group accounts by default.
+		self.set_account_type("Fixed Assets", "Fixed Asset")
+		self.set_account_type("Direct Income", "Direct Income")
+
+	def set_account_type(self, account_name, account_type):
+		frappe.db.set_value("Account", f"{account_name} - {self.abbr}", "account_type", account_type)
+
+	def test_fixed_asset_turnover_uses_net_fixed_assets(self):
+		# Acquire a fixed asset worth 10,000 funded by equity.
+		self.make_journal_entry("Buildings", "Capital Stock", 10000)
+		# Book sales of 20,000 collected in cash. Total assets now = 30,000
+		# (Buildings 10,000 + Cash 20,000), while net fixed assets stay at 10,000.
+		self.make_journal_entry("Cash", "Sales", 20000)
+
+		columns, data = execute(self.get_report_filters())
+		year_key = columns[1]["fieldname"]
+		ratio_row = next((row for row in data if row.get("ratio") == "Fixed Asset Turnover Ratio"), None)
+		self.assertIsNotNone(ratio_row, "Fixed Asset Turnover Ratio row not found in report output")
+
+		# Net Sales / Net Fixed Assets = 20,000 / 10,000 = 2.0
+		# (the old behaviour divided by total assets, giving 20,000 / 30,000 = 0.667)
+		self.assertEqual(ratio_row[year_key], 2.0)
+
+	def get_report_filters(self):
+		active_fy = frappe.db.get_value(
+			"Fiscal Year",
+			{"disabled": 0, "year_start_date": ("<=", today()), "year_end_date": (">=", today())},
+			["name", "year_start_date", "year_end_date"],
+			as_dict=True,
+		)
+		return frappe._dict(
+			company=self.company,
+			from_fiscal_year=active_fy.name,
+			to_fiscal_year=active_fy.name,
+			period_start_date=active_fy.year_start_date,
+			period_end_date=active_fy.year_end_date,
+			filter_based_on="Fiscal Year",
+			periodicity="Yearly",
+		)
+
+	def make_journal_entry(self, debit_account, credit_account, amount):
+		journal_entry = frappe.new_doc("Journal Entry")
+		journal_entry.posting_date = today()
+		journal_entry.company = self.company
+		for account, debit, credit in (
+			(debit_account, amount, 0),
+			(credit_account, 0, amount),
+		):
+			journal_entry.append(
+				"accounts",
+				{
+					"account": f"{account} - {self.abbr}",
+					"debit_in_account_currency": debit,
+					"credit_in_account_currency": credit,
+				},
+			)
+		journal_entry.insert()
+		journal_entry.submit()

erpnext/accounts/report/general_ledger/general_ledger.json

@@ -4,13 +4,20 @@
  "columns": [],
  "creation": "2013-12-06 13:22:23",
  "default_print_format": "General Ledger Standard",
+ "disable_prepared_report_automation": 0,
  "disabled": 0,
  "docstatus": 0,
  "doctype": "Report",
+ "doctype_to_sync": [
+  {
+   "doc_type": "GL Entry"
+  }
+ ],
  "filters": [],
+ "generate_csv": 0,
  "idx": 4,
  "is_standard": "Yes",
- "modified": "2026-05-22 14:34:35.246000",
+ "modified": "2026-07-01 13:36:06.682661",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "General Ledger",
@@ -30,5 +37,6 @@
    "role": "Auditor"
   }
  ],
+ "snapshot_report": 0,
  "timeout": 0
 }

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -818,3 +818,288 @@ def get_columns(filters):
 		columns.extend([{"label": _("Remarks"), "fieldname": "remarks", "width": 400}])
 
 	return columns
+
+
+def execute_snapshot_report(filters):
+	from frappe.database.duckdb.database import get_latest_sync
+
+	if conn := get_latest_sync("GL Entry"):
+		return _execute_with_duckdb_conn(filters, conn)
+
+	frappe.throw(_("General Ledger requires {0} to be synced to DuckDB").format(frappe.bold("GL Entry")))
+
+
+def _execute_with_duckdb_conn(filters, conn):
+	if not filters:
+		return [], []
+
+	account_details = {}
+
+	if filters.get("print_in_account_currency") and not filters.get("account"):
+		frappe.throw(_("Select an account to print in account currency"))
+
+	for acc in frappe.get_all("Account", fields=["name", "is_group"]):
+		account_details.setdefault(acc.name, acc)
+
+	if filters.get("party"):
+		filters.party = frappe.parse_json(filters.get("party"))
+
+	validate_filters(filters, account_details)
+	validate_party(filters)
+	filters = set_account_currency(filters)
+	columns = get_columns(filters)
+	res = get_result_duckdb(filters, account_details, conn)
+	return columns, res
+
+
+def get_result_duckdb(filters, account_details, conn):
+	accounting_dimensions = []
+	if filters.get("include_dimensions"):
+		accounting_dimensions = get_accounting_dimensions()
+
+	gl_entries = get_gl_entries_duckdb(filters, accounting_dimensions, conn)
+	data = get_data_with_opening_closing(filters, account_details, accounting_dimensions, gl_entries)
+	return get_result_as_list(data, filters)
+
+
+def get_gl_entries_duckdb(filters, accounting_dimensions, conn):
+	currency_map = get_currency(filters)
+
+	col_names = [
+		"gl_entry",
+		"posting_date",
+		"account",
+		"party_type",
+		"party",
+		"voucher_type",
+		"voucher_subtype",
+		"voucher_no",
+		"cost_center",
+		"project",
+		"against_voucher_type",
+		"against_voucher",
+		"account_currency",
+		"against",
+		"is_opening",
+		"creation",
+		"debit",
+		"credit",
+		"debit_in_account_currency",
+		"credit_in_account_currency",
+	]
+	select_exprs = [
+		"name",
+		"posting_date",
+		"account",
+		"party_type",
+		"party",
+		"voucher_type",
+		"voucher_subtype",
+		"voucher_no",
+		"cost_center",
+		"project",
+		"against_voucher_type",
+		"against_voucher",
+		"account_currency",
+		"against",
+		"is_opening",
+		"creation",
+		"debit",
+		"credit",
+		"debit_in_account_currency",
+		"credit_in_account_currency",
+	]
+
+	if filters.get("show_remarks"):
+		remarks_length = frappe.get_single_value("Accounts Settings", "general_ledger_remarks_length")
+		if remarks_length:
+			select_exprs.append(f"substr(remarks, 1, {int(remarks_length)})")
+		else:
+			select_exprs.append("remarks")
+		col_names.append("remarks")
+
+	if filters.get("add_values_in_transaction_currency"):
+		select_exprs += [
+			"debit_in_transaction_currency",
+			"credit_in_transaction_currency",
+			"transaction_currency",
+		]
+		col_names += [
+			"debit_in_transaction_currency",
+			"credit_in_transaction_currency",
+			"transaction_currency",
+		]
+
+	if accounting_dimensions:
+		select_exprs += accounting_dimensions
+		col_names += accounting_dimensions
+
+	order_by = "posting_date, account, creation"
+	if filters.get("include_dimensions"):
+		order_by = "posting_date, creation"
+	if filters.get("categorize_by") == "Categorize by Voucher":
+		order_by = "posting_date, voucher_type, voucher_no"
+	if filters.get("categorize_by") == "Categorize by Account":
+		order_by = "account, posting_date, creation"
+
+	if filters.get("include_default_book_entries"):
+		filters["company_fb"] = frappe.get_cached_value(
+			"Company", filters.get("company"), "default_finance_book"
+		)
+
+	conditions, params = _build_gl_conditions_duckdb(filters)
+	select_clause = ", ".join(select_exprs)
+	sql = f'SELECT {select_clause} FROM "tabGL Entry" WHERE {" AND ".join(conditions)} ORDER BY {order_by}'
+
+	rows = conn.execute(sql, params).fetchall()
+	gl_entries = [frappe._dict(zip(col_names, row, strict=False)) for row in rows]
+
+	party_name_map = get_party_name_map()
+	for gl_entry in gl_entries:
+		if gl_entry.party_type and gl_entry.party:
+			gl_entry.party_name = party_name_map.get(gl_entry.party_type, {}).get(gl_entry.party)
+
+	if filters.get("presentation_currency"):
+		return convert_to_presentation_currency(gl_entries, currency_map, filters)
+	return gl_entries
+
+
+def _build_gl_conditions_duckdb(filters):
+	ignore_is_opening = frappe.get_single_value("Accounts Settings", "ignore_is_opening_check_for_reporting")
+
+	conditions = ["company = ?"]
+	params = [filters.company]
+
+	if filters.get("account"):
+		filters.account = get_accounts_with_children(filters.account)
+		if filters.account:
+			conditions.append(f"account IN ({', '.join(['?'] * len(filters.account))})")
+			params.extend(filters.account)
+
+	if filters.get("cost_center"):
+		filters.cost_center = get_cost_centers_with_children(filters.cost_center)
+		conditions.append(f"cost_center IN ({', '.join(['?'] * len(filters.cost_center))})")
+		params.extend(filters.cost_center)
+
+	if filters.get("voucher_no"):
+		conditions.append("voucher_no = ?")
+		params.append(filters.voucher_no)
+
+	if filters.get("against_voucher_no"):
+		conditions.append("against_voucher = ?")
+		params.append(filters.against_voucher_no)
+
+	if filters.get("ignore_err"):
+		err_journals = frappe.db.get_all(
+			"Journal Entry",
+			filters={
+				"company": filters.get("company"),
+				"docstatus": 1,
+				"voucher_type": ("in", ["Exchange Rate Revaluation", "Exchange Gain Or Loss"]),
+			},
+			pluck="name",
+		)
+		if err_journals:
+			filters.update({"voucher_no_not_in": err_journals})
+
+	if filters.get("ignore_cr_dr_notes"):
+		system_generated = frappe.db.get_all(
+			"Journal Entry",
+			filters={
+				"company": filters.get("company"),
+				"docstatus": 1,
+				"voucher_type": ("in", ["Credit Note", "Debit Note"]),
+				"is_system_generated": 1,
+			},
+			pluck="name",
+		)
+		if system_generated:
+			vouchers_to_ignore = (filters.get("voucher_no_not_in") or []) + system_generated
+			filters.update({"voucher_no_not_in": vouchers_to_ignore})
+
+	if filters.get("voucher_no_not_in"):
+		vouchers = filters.voucher_no_not_in
+		conditions.append(f"voucher_no NOT IN ({', '.join(['?'] * len(vouchers))})")
+		params.extend(vouchers)
+
+	if filters.get("categorize_by") == "Categorize by Party" and not filters.get("party_type"):
+		conditions.append("party_type IN ('Customer', 'Supplier')")
+
+	if filters.get("party_type"):
+		conditions.append("party_type = ?")
+		params.append(filters.party_type)
+
+	if filters.get("party"):
+		conditions.append(f"party IN ({', '.join(['?'] * len(filters.party))})")
+		params.extend(filters.party)
+
+	# from_date: skip when filtering by account/party to allow opening balance calc in Python
+	if filters.get("disable_opening_balance_calculation"):
+		if not ignore_is_opening:
+			conditions.append("(posting_date >= ? OR is_opening = 'Yes')")
+		else:
+			conditions.append("posting_date >= ?")
+		params.append(filters.from_date)
+	elif not (
+		filters.get("account")
+		or filters.get("party")
+		or filters.get("categorize_by") in ["Categorize by Account", "Categorize by Party"]
+	):
+		if not ignore_is_opening:
+			conditions.append("(posting_date >= ? OR is_opening = 'Yes')")
+		else:
+			conditions.append("posting_date >= ?")
+		params.append(filters.from_date)
+
+	if not ignore_is_opening:
+		conditions.append("(posting_date <= ? OR is_opening = 'Yes')")
+	else:
+		conditions.append("posting_date <= ?")
+	params.append(filters.to_date)
+
+	if filters.get("project"):
+		conditions.append(f"project IN ({', '.join(['?'] * len(filters.project))})")
+		params.extend(filters.project)
+
+	company_fb = filters.get("company_fb") or frappe.get_cached_value(
+		"Company", filters.company, "default_finance_book"
+	)
+	if filters.get("include_default_book_entries"):
+		if filters.get("finance_book"):
+			if company_fb and cstr(filters.finance_book) != cstr(company_fb):
+				frappe.throw(
+					_("To use a different finance book, please uncheck 'Include Default FB Entries'")
+				)
+			fb_vals = [cstr(filters.finance_book), ""]
+		else:
+			fb_vals = [cstr(company_fb), ""]
+		conditions.append(f"(finance_book IN ({', '.join(['?'] * len(fb_vals))}) OR finance_book IS NULL)")
+		params.extend(fb_vals)
+	else:
+		if filters.get("finance_book"):
+			conditions.append("(finance_book IN (?, '') OR finance_book IS NULL)")
+			params.append(cstr(filters.finance_book))
+		else:
+			conditions.append("(finance_book IN ('') OR finance_book IS NULL)")
+
+	if not filters.get("show_cancelled_entries"):
+		conditions.append("is_cancelled = 0")
+
+	accounting_dimensions_list = get_accounting_dimensions(as_list=False)
+	if accounting_dimensions_list:
+		for dimension in accounting_dimensions_list:
+			if not dimension.disabled and dimension.document_type != "Finance Book":
+				if filters.get(dimension.fieldname):
+					if frappe.get_cached_value("DocType", dimension.document_type, "is_tree"):
+						filters[dimension.fieldname] = get_dimension_with_children(
+							dimension.document_type, filters.get(dimension.fieldname)
+						)
+					vals = (
+						filters[dimension.fieldname]
+						if isinstance(filters[dimension.fieldname], list)
+						else [filters[dimension.fieldname]]
+					)
+					conditions.append(f"{dimension.fieldname} IN ({', '.join(['?'] * len(vals))})")
+					params.extend(vals)
+
+	return conditions, params

erpnext/accounts/report/gross_profit/gross_profit.py

@@ -562,7 +562,12 @@ class GrossProfitGenerator:
 								row.base_amount = packed_item.base_amount
 
 			# get buying amount
-			if row.item_code in product_bundles:
+			if row.is_debit_note:
+				# Rate adjustment debit notes have no stock movement, so buying amount is zero
+				if not grouped_by_invoice:
+					row.qty = 0
+				row.buying_amount = 0
+			elif row.item_code in product_bundles:
 				row.buying_amount = flt(
 					self.get_buying_amount_from_product_bundle(row, product_bundles[row.item_code]),
 					self.currency_precision,
@@ -951,6 +956,7 @@ class GrossProfitGenerator:
 			SalesInvoice.customer_group,
 			SalesInvoice.customer_name,
 			SalesInvoice.territory,
+			SalesInvoice.is_debit_note,
 			SalesInvoiceItem.item_code,
 			SalesInvoice.base_net_total.as_("invoice_base_net_total"),
 			SalesInvoiceItem.item_name,
@@ -1131,6 +1137,7 @@ class GrossProfitGenerator:
 				"posting_time": row.posting_time,
 				"project": row.project,
 				"update_stock": row.update_stock,
+				"is_debit_note": row.is_debit_note,
 				"customer": row.customer,
 				"customer_group": row.customer_group,
 				"customer_name": row.customer_name,
@@ -1169,6 +1176,7 @@ class GrossProfitGenerator:
 				"description": item.description,
 				"warehouse": item.warehouse or row.warehouse,
 				"update_stock": row.update_stock,
+				"is_debit_note": row.is_debit_note,
 				"item_group": "",
 				"brand": "",
 				"dn_detail": row.dn_detail,

erpnext/accounts/report/gross_profit/test_gross_profit.py

@@ -14,71 +14,17 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestGrossProfit(ERPNextTestSuite):
 	def setUp(self):
-		self.create_company()
-		self.create_item()
-		self.create_bundle()
-		self.create_customer()
-
-	def create_company(self):
-		company_name = "_Test Gross Profit"
-		abbr = "_GP"
-		if frappe.db.exists("Company", company_name):
-			company = frappe.get_doc("Company", company_name)
-		else:
-			company = frappe.get_doc(
-				{
-					"doctype": "Company",
-					"company_name": company_name,
-					"country": "India",
-					"default_currency": "INR",
-					"create_chart_of_accounts_based_on": "Standard Template",
-					"chart_of_accounts": "Standard",
-				}
-			)
-			company = company.save()
-
-		self.company = company.name
-		self.cost_center = company.cost_center
-		self.warehouse = "Stores - " + abbr
-		self.finished_warehouse = "Finished Goods - " + abbr
-		self.income_account = "Sales - " + abbr
-		self.expense_account = "Cost of Goods Sold - " + abbr
-		self.debit_to = "Debtors - " + abbr
-		self.creditors = "Creditors - " + abbr
-
-	def create_item(self):
-		item = create_item(
-			item_code="_Test GP Item", is_stock_item=1, company=self.company, warehouse=self.warehouse
-		)
-		self.item = item if isinstance(item, str) else item.item_code
-
-	def create_bundle(self):
-		from erpnext.selling.doctype.product_bundle.test_product_bundle import make_product_bundle
-
-		item2 = create_item(
-			item_code="_Test GP Item 2", is_stock_item=1, company=self.company, warehouse=self.warehouse
-		)
-		self.item2 = item2 if isinstance(item2, str) else item2.item_code
-
-		# This will be parent item
-		bundle = create_item(
-			item_code="_Test GP bundle", is_stock_item=0, company=self.company, warehouse=self.warehouse
-		)
-		self.bundle = bundle if isinstance(bundle, str) else bundle.item_code
-
-		# Create Product Bundle
-		self.product_bundle = make_product_bundle(parent=self.bundle, items=[self.item, self.item2])
-
-	def create_customer(self):
-		name = "_Test GP Customer"
-		if frappe.db.exists("Customer", name):
-			self.customer = name
-		else:
-			customer = frappe.new_doc("Customer")
-			customer.customer_name = name
-			customer.type = "Individual"
-			customer.save()
-			self.customer = customer.name
+		self.company = "_Test Company"
+		self.cost_center = "Main - _TC"
+		self.warehouse = "Stores - _TC"
+		self.finished_warehouse = "Finished Goods - _TC"
+		self.income_account = "Sales - _TC"
+		self.expense_account = "Cost of Goods Sold - _TC"
+		self.debit_to = "Debtors - _TC"
+		self.item = "_Test Item"
+		self.item2 = "_Test Item Home Desktop 100"
+		self.bundle = "_Test Product Bundle Item"
+		self.customer = "_Test Customer"
 
 	def create_sales_invoice(
 		self, qty=1, rate=100, posting_date=None, do_not_save=False, do_not_submit=False
@@ -212,7 +158,7 @@ class TestGrossProfit(ERPNextTestSuite):
 			"posting_date": frappe.utils.datetime.date.fromisoformat(nowdate()),
 			"item_code": self.item,
 			"item_name": self.item,
-			"warehouse": "Stores - _GP",
+			"warehouse": "Stores - _TC",
 			"qty": 1.0,
 			"avg._selling_rate": 100.0,
 			"valuation_rate": 150.0,
@@ -241,7 +187,7 @@ class TestGrossProfit(ERPNextTestSuite):
 			"posting_date": frappe.utils.datetime.date.fromisoformat(nowdate()),
 			"item_code": self.item,
 			"item_name": self.item,
-			"warehouse": "Stores - _GP",
+			"warehouse": "Stores - _TC",
 			"qty": 1.0,
 			"avg._selling_rate": 100.0,
 			"valuation_rate": 100.0,
@@ -273,7 +219,7 @@ class TestGrossProfit(ERPNextTestSuite):
 				"item_code": self.item2,
 				"s_warehouse": "",
 				"t_warehouse": self.finished_warehouse,
-				"qty": 1,
+				"qty": 2,
 				"basic_rate": 100,
 				"conversion_factor": item.conversion_factor or 1.0,
 				"transfer_qty": flt(item.qty) * (flt(item.conversion_factor) or 1.0),
@@ -373,7 +319,7 @@ class TestGrossProfit(ERPNextTestSuite):
 			"posting_date": frappe.utils.datetime.date.fromisoformat(nowdate()),
 			"item_code": self.item,
 			"item_name": self.item,
-			"warehouse": "Stores - _GP",
+			"warehouse": "Stores - _TC",
 			"qty": 4.0,
 			"avg._selling_rate": 100.0,
 			"valuation_rate": 125.0,
@@ -414,10 +360,10 @@ class TestGrossProfit(ERPNextTestSuite):
 			"posting_date": frappe.utils.datetime.date.fromisoformat(nowdate()),
 			"item_code": self.item,
 			"item_name": self.item,
-			"warehouse": "Stores - _GP",
+			"warehouse": "Stores - _TC",
 			"qty": 0.0,
-			"avg._selling_rate": 100,
-			"valuation_rate": 0.0,
+			"avg._selling_rate": 100.0,
+			"valuation_rate": 100.0,
 			"selling_amount": 0.0,
 			"buying_amount": 0.0,
 			"gross_profit": 0.0,
@@ -437,7 +383,7 @@ class TestGrossProfit(ERPNextTestSuite):
 		"""
 		# Make Cr Note
 		sinv = self.create_sales_invoice(
-			qty=-1, rate=100, posting_date=nowdate(), do_not_save=True, do_not_submit=True
+			qty=-1, rate=200, posting_date=nowdate(), do_not_save=True, do_not_submit=True
 		)
 		sinv.is_return = 1
 		sinv.items[0].allow_zero_valuation_rate = 1
@@ -460,14 +406,14 @@ class TestGrossProfit(ERPNextTestSuite):
 			"posting_date": frappe.utils.datetime.date.fromisoformat(nowdate()),
 			"item_code": self.item,
 			"item_name": self.item,
-			"warehouse": "Stores - _GP",
+			"warehouse": "Stores - _TC",
 			"qty": -1.0,
-			"avg._selling_rate": 100.0,
-			"valuation_rate": 0.0,
-			"selling_amount": -100.0,
-			"buying_amount": 0.0,
+			"avg._selling_rate": 200.0,
+			"valuation_rate": 100.0,
+			"selling_amount": -200.0,
+			"buying_amount": -100.0,
 			"gross_profit": -100.0,
-			"gross_profit_%": -100.0,
+			"gross_profit_%": -50.0,
 		}
 		gp_entry = [x for x in data if x.parent_invoice == sinv.name]
 		report_output = {k: v for k, v in gp_entry[0].items() if k in expected_entry}
@@ -553,7 +499,7 @@ class TestGrossProfit(ERPNextTestSuite):
 			"posting_date": frappe.utils.datetime.date.fromisoformat(nowdate()),
 			"item_code": self.item,
 			"item_name": self.item,
-			"warehouse": "Stores - _GP",
+			"warehouse": "Stores - _TC",
 			"qty": 4.0,
 			"avg._selling_rate": 800.0,
 			"valuation_rate": 700.0,
@@ -616,7 +562,7 @@ class TestGrossProfit(ERPNextTestSuite):
 	def test_gross_profit_groupby_invoices(self):
 		create_sales_invoice(
 			qty=1,
-			rate=100,
+			rate=200,
 			company=self.company,
 			customer=self.customer,
 			item_code=self.item,
@@ -638,10 +584,10 @@ class TestGrossProfit(ERPNextTestSuite):
 		_, data = execute(filters=filters)
 		total = data[-1]
 
-		self.assertEqual(total.selling_amount, 100.0)
-		self.assertEqual(total.buying_amount, 0.0)
+		self.assertEqual(total.selling_amount, 200.0)
+		self.assertEqual(total.buying_amount, 100.0)
 		self.assertEqual(total.gross_profit, 100.0)
-		self.assertEqual(total.get("gross_profit_%"), 100.0)
+		self.assertEqual(total.get("gross_profit_%"), 50.0)
 
 	def test_profit_for_later_period_return(self):
 		month_start_date, month_end_date = get_first_day(nowdate()), get_last_day(nowdate())
@@ -650,7 +596,7 @@ class TestGrossProfit(ERPNextTestSuite):
 		return_inv_date = add_days(month_end_date, 1)
 
 		# create sales invoice on month start date
-		sinv = self.create_sales_invoice(qty=1, rate=100, do_not_save=True, do_not_submit=True)
+		sinv = self.create_sales_invoice(qty=1, rate=200, do_not_save=True, do_not_submit=True)
 		sinv.set_posting_time = 1
 		sinv.posting_date = sales_inv_date
 		sinv.save().submit()
@@ -669,10 +615,10 @@ class TestGrossProfit(ERPNextTestSuite):
 		_, data = execute(filters=filters)
 		total = data[-1]
 
-		self.assertEqual(total.selling_amount, 100.0)
-		self.assertEqual(total.buying_amount, 0.0)
+		self.assertEqual(total.selling_amount, 200.0)
+		self.assertEqual(total.buying_amount, 100.0)
 		self.assertEqual(total.gross_profit, 100.0)
-		self.assertEqual(total.get("gross_profit_%"), 100.0)
+		self.assertEqual(total.get("gross_profit_%"), 50.0)
 
 		# extend filters upto returned period
 		filters.update({"to_date": return_inv_date})
@@ -690,10 +636,10 @@ class TestGrossProfit(ERPNextTestSuite):
 		_, data = execute(filters=filters)
 		total = data[-1]
 
-		self.assertEqual(total.selling_amount, -100.0)
-		self.assertEqual(total.buying_amount, 0.0)
+		self.assertEqual(total.selling_amount, -200.0)
+		self.assertEqual(total.buying_amount, -100.0)
 		self.assertEqual(total.gross_profit, -100.0)
-		self.assertEqual(total.get("gross_profit_%"), -100.0)
+		self.assertEqual(total.get("gross_profit_%"), -50.0)
 
 	def test_sales_person_wise_gross_profit(self):
 		sales_person = make_sales_person("_Test Sales Person")
@@ -724,10 +670,10 @@ class TestGrossProfit(ERPNextTestSuite):
 		_, data = execute(filters=filters)
 		total = data[-1]
 
-		self.assertEqual(total[5], 1000.0)
-		self.assertEqual(total[6], 0.0)
-		self.assertEqual(total[7], 1000.0)
-		self.assertEqual(total[8], 100.0)
+		self.assertEqual(total[5], 1000.0)  # selling amount
+		self.assertEqual(total[6], 1000.0)  # buying amount
+		self.assertEqual(total[7], 0.0)  # gross profit
+		self.assertEqual(total[8], 0.0)  # gross profit %
 
 	def test_drop_ship(self):
 		from erpnext.buying.doctype.purchase_order.purchase_order import make_purchase_invoice
@@ -754,6 +700,160 @@ class TestGrossProfit(ERPNextTestSuite):
 		self.assertIsNone(data[1].buying_rate)
 		self.assertEqual(data[1]["gross_profit_%"], 20)
 
+	def create_rate_adjustment_debit_note(self, against_invoice, adjustment_rate, item_code=None):
+		"""Create a rate adjustment debit note with no stock movement."""
+		dn = self.create_sales_invoice(qty=1, rate=adjustment_rate, do_not_save=True, do_not_submit=True)
+		if item_code:
+			dn.items[0].item_code = item_code
+			dn.items[0].item_name = item_code
+		dn.is_debit_note = 1
+		dn.return_against = against_invoice.name
+		dn.items[0].allow_zero_valuation_rate = 1
+		return dn.save().submit()
+
+	def test_debit_note_has_zero_buying_amount_and_full_gross_profit(self):
+		"""
+		Rate adjustment debit note (is_debit_note=1) should show buying_amount=0
+		since there is no stock movement. Gross profit equals the adjustment amount
+		and gross profit % equals 100%.
+		"""
+		make_stock_entry(
+			company=self.company,
+			item_code=self.item,
+			target=self.warehouse,
+			qty=1,
+			basic_rate=100,
+		)
+
+		sinv = self.create_sales_invoice(qty=1, rate=200, do_not_submit=True)
+		sinv.update_stock = 1
+		sinv = sinv.save().submit()
+
+		debit_note = self.create_rate_adjustment_debit_note(sinv, adjustment_rate=20)
+
+		filters = frappe._dict(
+			company=self.company,
+			from_date=nowdate(),
+			to_date=nowdate(),
+			group_by="Invoice",
+		)
+
+		columns, data = execute(filters=filters)
+
+		dn_item_rows = [
+			x for x in data if x.get("parent_invoice") == debit_note.name and x.get("indent") == 1.0
+		]
+		self.assertEqual(len(dn_item_rows), 1)
+
+		dn_row = dn_item_rows[0]
+		self.assertEqual(dn_row.buying_amount, 0.0)
+		self.assertEqual(dn_row.selling_amount, 20.0)
+		self.assertEqual(dn_row.gross_profit, 20.0)
+		self.assertEqual(dn_row["gross_profit_%"], 100.0)
+
+	def test_original_invoice_unaffected_by_rate_adjustment_debit_note(self):
+		"""
+		The original invoice's GP should be derived solely from its own selling
+		amount and COGS — the rate adjustment debit note must not alter it.
+		"""
+		make_stock_entry(
+			company=self.company,
+			item_code=self.item,
+			target=self.warehouse,
+			qty=1,
+			basic_rate=100,
+		)
+
+		sinv = self.create_sales_invoice(qty=1, rate=200, do_not_submit=True)
+		sinv.update_stock = 1
+		sinv = sinv.save().submit()
+
+		self.create_rate_adjustment_debit_note(sinv, adjustment_rate=20)
+
+		filters = frappe._dict(
+			company=self.company,
+			from_date=nowdate(),
+			to_date=nowdate(),
+			group_by="Invoice",
+		)
+
+		columns, data = execute(filters=filters)
+
+		sinv_item_rows = [x for x in data if x.get("parent_invoice") == sinv.name and x.get("indent") == 1.0]
+		self.assertEqual(len(sinv_item_rows), 1)
+
+		sinv_row = sinv_item_rows[0]
+		self.assertEqual(sinv_row.selling_amount, 200.0)
+		self.assertEqual(sinv_row.buying_amount, 100.0)
+		self.assertEqual(sinv_row.gross_profit, 100.0)
+		self.assertEqual(sinv_row["gross_profit_%"], 50.0)
+
+	def test_debit_note_qty_not_inflated_in_grouped_report(self):
+		"""
+		When grouped by Item Code, the debit note (qty=0) must not inflate
+		the group's qty or buying_amount. The selling amount and average
+		selling rate correctly reflect the rate adjustment.
+		"""
+		item = create_item("_Test Rate Adjustment Debit Note Item")
+
+		make_stock_entry(
+			company=self.company,
+			item_code=item.item_code,
+			target=self.warehouse,
+			qty=1,
+			basic_rate=100,
+		)
+
+		sinv = create_sales_invoice(
+			qty=1,
+			rate=200,
+			company=self.company,
+			customer=self.customer,
+			item_code=item.item_code,
+			item_name=item.item_code,
+			cost_center=self.cost_center,
+			warehouse=self.warehouse,
+			debit_to=self.debit_to,
+			parent_cost_center=self.cost_center,
+			update_stock=1,
+			currency="INR",
+			income_account=self.income_account,
+			expense_account=self.expense_account,
+		)
+
+		self.create_rate_adjustment_debit_note(sinv, adjustment_rate=20, item_code=item.item_code)
+
+		filters = frappe._dict(
+			company=self.company,
+			from_date=nowdate(),
+			to_date=nowdate(),
+			group_by="Item Code",
+		)
+
+		columns, data = execute(filters=filters)
+
+		# group_by="Item Code" column order:
+		# [item_code, item_name, brand, description, qty, base_rate,
+		#  buying_rate, base_amount, buying_amount, gross_profit, gross_profit_percent, currency]
+		item_row = next((row for row in data if row[0] == item.item_code), None)
+		self.assertIsNotNone(item_row)
+
+		qty, base_rate, buying_amount, base_amount, gross_profit, gp_percent = (
+			item_row[4],
+			item_row[5],
+			item_row[8],
+			item_row[7],
+			item_row[9],
+			item_row[10],
+		)
+
+		self.assertEqual(qty, 1.0)  # debit note adds qty=0, not inflated
+		self.assertEqual(buying_amount, 100.0)  # only original invoice COGS
+		self.assertEqual(base_amount, 220.0)  # 200 (original) + 20 (adjustment)
+		self.assertEqual(base_rate, 220.0)  # avg selling rate = 220/1
+		self.assertEqual(gross_profit, 120.0)  # 220 - 100
+		self.assertAlmostEqual(gp_percent, 54.545, places=2)  # 120/220 * 100
+
 
 def make_sales_person(sales_person_name="_Test Sales Person"):
 	if not frappe.db.exists("Sales Person", {"sales_person_name": sales_person_name}):

erpnext/accounts/report/payment_ledger/test_payment_ledger.py

@@ -9,42 +9,12 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestPaymentLedger(ERPNextTestSuite):
 	def setUp(self):
-		self.create_company()
-		self.cleanup()
-
-	def cleanup(self):
-		doctypes = []
-		doctypes.append(qb.DocType("GL Entry"))
-		doctypes.append(qb.DocType("Payment Ledger Entry"))
-		doctypes.append(qb.DocType("Sales Invoice"))
-		doctypes.append(qb.DocType("Payment Entry"))
-
-		for doctype in doctypes:
-			qb.from_(doctype).delete().where(doctype.company == self.company).run()
-
-	def create_company(self):
-		name = "Test Payment Ledger"
-		company = None
-		if frappe.db.exists("Company", name):
-			company = frappe.get_doc("Company", name)
-		else:
-			company = frappe.get_doc(
-				{
-					"doctype": "Company",
-					"company_name": name,
-					"country": "India",
-					"default_currency": "INR",
-					"create_chart_of_accounts_based_on": "Standard Template",
-					"chart_of_accounts": "Standard",
-				}
-			)
-			company = company.save()
-		self.company = company.name
-		self.cost_center = company.cost_center
-		self.warehouse = "All Warehouses" + " - " + company.abbr
-		self.income_account = company.default_income_account
-		self.expense_account = company.default_expense_account
-		self.debit_to = company.default_receivable_account
+		self.company = "_Test Company"
+		self.cost_center = "Main - _TC"
+		self.warehouse = "Stores - _TC"
+		self.income_account = "Sales - _TC"
+		self.expense_account = "Cost of Goods Sold - _TC"
+		self.debit_to = "Debtors - _TC"
 
 	def test_unpaid_invoice_outstanding(self):
 		sinv = create_sales_invoice(

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.json

@@ -4,13 +4,20 @@
  "columns": [],
  "creation": "2014-07-18 11:43:33.173207",
  "default_print_format": "P&L Statement Standard",
+ "disable_prepared_report_automation": 0,
  "disabled": 0,
  "docstatus": 0,
  "doctype": "Report",
+ "doctype_to_sync": [
+  {
+   "doc_type": "GL Entry"
+  }
+ ],
  "filters": [],
+ "generate_csv": 0,
  "idx": 2,
  "is_standard": "Yes",
- "modified": "2026-05-22 14:36:04.544347",
+ "modified": "2026-07-01 13:36:14.934965",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Profit and Loss Statement",
@@ -30,5 +37,6 @@
    "role": "Auditor"
   }
  ],
+ "snapshot_report": 0,
  "timeout": 0
 }

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py

@@ -11,12 +11,20 @@ from erpnext.accounts.doctype.financial_report_template.financial_report_engine
 	get_xlsx_styles,  #! DO NOT REMOVE - hook for styling
 )
 from erpnext.accounts.report.financial_statements import (
+	accumulate_values_into_parents,
+	add_total_row,
+	calculate_values,
 	compute_growth_view_data,
 	compute_margin_view_data,
+	filter_accounts,
+	filter_out_zero_value_rows,
+	get_accounts,
+	get_appropriate_currency,
 	get_columns,
 	get_data,
 	get_filtered_list_for_consolidated_report,
 	get_period_list,
+	prepare_data,
 )
 
 
@@ -197,3 +205,125 @@ def get_chart_data(filters, chart_columns, income, expense, net_profit_loss, cur
 	chart["currency"] = currency
 
 	return chart
+
+
+def execute_snapshot_report(filters):
+	from frappe.database.duckdb.database import get_latest_sync
+
+	if not (conn := get_latest_sync("GL Entry")):
+		frappe.throw(
+			_("Profit and Loss Statement requires {0} to be synced to DuckDB").format(frappe.bold("GL Entry"))
+		)
+
+	period_list = get_period_list(
+		filters.from_fiscal_year,
+		filters.to_fiscal_year,
+		filters.period_start_date,
+		filters.period_end_date,
+		filters.filter_based_on,
+		filters.periodicity,
+		company=filters.company,
+	)
+
+	income = _get_data_duckdb(conn, filters, "Income", "Credit", period_list)
+	expense = _get_data_duckdb(conn, filters, "Expense", "Debit", period_list)
+
+	net_profit_loss = get_net_profit_loss(
+		income, expense, period_list, filters.company, filters.presentation_currency
+	)
+
+	data = []
+	data.extend(income or [])
+	data.extend(expense or [])
+	if net_profit_loss:
+		data.append(net_profit_loss)
+
+	columns = get_columns(filters.periodicity, period_list, filters.accumulated_values, filters.company)
+
+	currency = filters.presentation_currency or frappe.get_cached_value(
+		"Company", filters.company, "default_currency"
+	)
+	chart = get_chart_data(filters, period_list, income, expense, net_profit_loss, currency)
+
+	report_summary, primitive_summary = get_report_summary(
+		period_list, filters.periodicity, income, expense, net_profit_loss, currency, filters
+	)
+
+	if filters.get("selected_view") == "Growth":
+		compute_growth_view_data(data, period_list)
+
+	if filters.get("selected_view") == "Margin":
+		compute_margin_view_data(data, period_list, filters.accumulated_values)
+
+	return columns, data, None, chart, report_summary, primitive_summary
+
+
+def _get_data_duckdb(conn, filters, root_type, balance_must_be, period_list):
+	accounts = get_accounts(filters.company, root_type)
+	if not accounts:
+		return None
+
+	accounts, accounts_by_name, parent_children_map = filter_accounts(accounts)
+	company_currency = get_appropriate_currency(filters.company, filters)
+
+	gl_entries_by_account = {}
+	_load_gl_entries_duckdb(conn, filters, period_list, accounts, gl_entries_by_account)
+
+	calculate_values(
+		accounts_by_name,
+		gl_entries_by_account,
+		period_list,
+		filters.accumulated_values,
+		False,
+	)
+	accumulate_values_into_parents(accounts, accounts_by_name, period_list)
+
+	out = prepare_data(
+		accounts,
+		balance_must_be,
+		period_list,
+		company_currency,
+		accumulated_values=filters.accumulated_values,
+	)
+	out = filter_out_zero_value_rows(out, parent_children_map, filters.show_zero_values)
+
+	if out:
+		add_total_row(out, root_type, balance_must_be, period_list, company_currency)
+
+	return out
+
+
+def _load_gl_entries_duckdb(conn, filters, period_list, accounts, gl_entries_by_account):
+	from erpnext.accounts.report.trial_balance.trial_balance import (
+		_extra_gl_conditions,
+		_fetch_gl_rows_duckdb,
+	)
+	from erpnext.accounts.report.utils import convert_to_presentation_currency, get_currency
+
+	company = filters.company
+	leaf_accounts = [acc.name for acc in accounts if not acc.is_group]
+	if not leaf_accounts:
+		return
+
+	extra_cond, extra_params = _extra_gl_conditions(filters)
+	account_placeholders = ", ".join(["?"] * len(leaf_accounts))
+	base_conds = [
+		"company = ?",
+		"is_cancelled = 0",
+		f"account IN ({account_placeholders})",
+		"voucher_type != 'Period Closing Voucher'",
+	]
+	base_params = [company, *leaf_accounts]
+	base_conds.extend(extra_cond)
+	base_params.extend(extra_params)
+
+	for period in period_list:
+		period_conds = [*base_conds, "posting_date >= ?", "posting_date <= ?"]
+		period_params = [*base_params, period.from_date, period.to_date]
+
+		period_entries = _fetch_gl_rows_duckdb(conn, period_conds, period_params)
+		if filters.get("presentation_currency"):
+			convert_to_presentation_currency(period_entries, get_currency(filters))
+		for entry in period_entries:
+			entry.posting_date = period.to_date
+			gl_entries_by_account.setdefault(entry.account, []).append(entry)

erpnext/accounts/report/purchase_register/purchase_register.py

@@ -4,6 +4,7 @@
 
 import frappe
 from frappe import _, msgprint
+from frappe.model.meta import get_field_precision
 from frappe.query_builder.custom import ConstantColumn
 from frappe.utils import flt, getdate
 from pypika.terms import Bracket, LiteralValue, Order
@@ -125,17 +126,32 @@ def _execute(filters=None, additional_table_columns=None):
 				row.update({frappe.scrub(tax_acc): tax_amount})
 
 		# total tax, grand total, rounded total & outstanding amount
+
+		outstanding_precision = (
+			get_field_precision(
+				frappe.get_meta("Purchase Invoice").get_field("outstanding_amount"),
+				currency=company_currency,
+			)
+			or 2
+		)
 		row.update(
 			{
 				"total_tax": total_tax,
 				"grand_total": inv.base_grand_total,
 				"rounded_total": inv.base_rounded_total,
-				"outstanding_amount": inv.outstanding_amount,
 			}
 		)
 
 		if inv.doctype == "Purchase Invoice":
-			row.update({"debit": inv.base_grand_total, "credit": 0.0})
+			row.update(
+				{
+					"debit": inv.base_grand_total,
+					"credit": 0.0,
+					"outstanding_amount": flt(
+						(inv.outstanding_amount * (inv.conversion_rate or 1)), outstanding_precision
+					),
+				}
+			)
 		else:
 			row.update({"debit": 0.0, "credit": inv.base_grand_total})
 		data.append(row)
@@ -395,6 +411,7 @@ def get_invoices(filters, additional_query_columns):
 			pi.base_rounded_total,
 			pi.outstanding_amount,
 			pi.mode_of_payment,
+			pi.conversion_rate,
 		)
 		.where(pi.docstatus == 1)
 	)

erpnext/accounts/report/purchase_register/test_purchase_register.py

@@ -2,7 +2,7 @@
 # MIT License. See license.txt
 
 import frappe
-from frappe.utils import add_months, today
+from frappe.utils import add_months, flt, today
 
 from erpnext.accounts.report.purchase_register.purchase_register import execute
 from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
@@ -67,6 +67,35 @@ class TestPurchaseRegister(ERPNextTestSuite):
 		self.assertEqual(first_row.total_tax, 100)
 		self.assertEqual(first_row.grand_total, 1100)
 
+	def test_purchase_currency_conversion(self):
+		usd_creditors = frappe.get_doc(
+			{
+				"doctype": "Account",
+				"account_name": "USD Creditors",
+				"parent_account": "Accounts Payable - _TC",
+				"company": "_Test Company",
+				"account_type": "Payable",
+				"root_type": "Liability",
+				"report_type": "Balance Sheet",
+				"account_currency": "USD",
+			}
+		).insert()
+		foreign_invoice = make_purchase_invoice()
+		foreign_invoice.db_set("currency", "USD")
+		foreign_invoice.db_set("conversion_rate", 80)
+		foreign_invoice.db_set("credit_to", usd_creditors.name)
+		foreign_invoice.db_set("outstanding_amount", 100.236)
+		local_invoice = make_purchase_invoice()
+		local_invoice.db_set("currency", "INR")
+		local_invoice.db_set("conversion_rate", 1)
+		local_invoice.db_set("outstanding_amount", 200.456)
+		columns, data, *_ = execute(frappe._dict({"company": foreign_invoice.company}))
+		outstanding_precision = 2
+
+		data_by_name = {x.get("voucher_no"): x.get("outstanding_amount") for x in data}
+		self.assertEqual(data_by_name.get(foreign_invoice.name), flt((100.236 * 80), outstanding_precision))
+		self.assertEqual(data_by_name.get(local_invoice.name), flt(200.456, outstanding_precision))
+
 	def test_purchase_register_ledger_view(self):
 		filters = frappe._dict(
 			company="_Test Company 6",

erpnext/accounts/report/sales_register/sales_register.py

@@ -141,17 +141,31 @@ def _execute(filters, additional_table_columns=None):
 
 		# total tax, grand total, outstanding amount & rounded total
 
+		outstanding_precision = (
+			get_field_precision(
+				frappe.get_meta("Sales Invoice").get_field("outstanding_amount"),
+				currency=company_currency,
+			)
+			or 2
+		)
 		row.update(
 			{
 				"tax_total": total_tax,
 				"grand_total": inv.base_grand_total,
 				"rounded_total": inv.base_rounded_total,
-				"outstanding_amount": inv.outstanding_amount,
 			}
 		)
 
 		if inv.doctype == "Sales Invoice":
-			row.update({"debit": inv.base_grand_total, "credit": 0.0})
+			row.update(
+				{
+					"debit": inv.base_grand_total,
+					"credit": 0.0,
+					"outstanding_amount": flt(
+						(inv.outstanding_amount * (inv.conversion_rate or 1)), outstanding_precision
+					),
+				}
+			)
 		else:
 			row.update({"debit": 0.0, "credit": inv.base_grand_total})
 		data.append(row)
@@ -437,6 +451,7 @@ def get_invoices(filters, additional_query_columns):
 			si.is_internal_customer,
 			si.represents_company,
 			si.company,
+			si.conversion_rate,
 		)
 		.where(si.docstatus == 1)
 	)

erpnext/accounts/report/sales_register/test_sales_register.py

@@ -1,9 +1,10 @@
 import frappe
-from frappe.utils import getdate, today
+from frappe.utils import add_days, flt, getdate, today
 
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.report.sales_register.sales_register import execute
 from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+from erpnext.selling.doctype.customer.test_customer import make_customer
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.tests.utils import ERPNextTestSuite
 
@@ -216,3 +217,25 @@ class TestItemWiseSalesRegister(ERPNextTestSuite, AccountsTestMixin):
 		}
 		result_output = {k: v for k, v in filtered_output[0].items() if k in expected_result}
 		self.assertDictEqual(result_output, expected_result)
+
+	def test_outstanding_currency_conversion(self):
+		foreign_invoice = create_sales_invoice(
+			customer="_Test Customer",
+			posting_date=add_days(today(), -1),
+			qty=1,
+			rate=100,
+		)
+		foreign_invoice.db_set("currency", "USD")
+		foreign_invoice.db_set("conversion_rate", 80)
+		foreign_invoice.db_set("outstanding_amount", 100.236)
+		make_customer("_Test Customer2")
+		local_invoice = create_sales_invoice(
+			customer="_Test Customer2", currency="INR", conversion_rate=1, qty=1, rate=200
+		)
+		local_invoice.db_set("outstanding_amount", 200.456)
+		columns, data, *_ = execute(frappe._dict({"company": foreign_invoice.company}))
+		outstanding_precision = 2
+
+		data_by_name = {x.get("voucher_no"): x.get("outstanding_amount") for x in data}
+		self.assertEqual(data_by_name.get(foreign_invoice.name), flt((100.236 * 80), outstanding_precision))
+		self.assertEqual(data_by_name.get(local_invoice.name), flt(200.456, outstanding_precision))

erpnext/accounts/report/trial_balance/trial_balance.json

@@ -4,13 +4,20 @@
  "columns": [],
  "creation": "2014-07-22 11:41:23.743564",
  "default_print_format": "Trial Balance Standard",
+ "disable_prepared_report_automation": 0,
  "disabled": 0,
  "docstatus": 0,
  "doctype": "Report",
+ "doctype_to_sync": [
+  {
+   "doc_type": "GL Entry"
+  }
+ ],
  "filters": [],
- "idx": 2,
+ "generate_csv": 0,
+ "idx": 4,
  "is_standard": "Yes",
- "modified": "2026-05-22 14:35:44.889062",
+ "modified": "2026-07-01 17:32:21.801141",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Trial Balance",
@@ -30,5 +37,6 @@
    "role": "Auditor"
   }
  ],
+ "snapshot_report": 0,
  "timeout": 0
 }

erpnext/accounts/report/trial_balance/trial_balance.py

@@ -571,3 +571,215 @@ def hide_group_accounts(data):
 			d.update(indent=0)
 			non_group_accounts_data.append(d)
 	return non_group_accounts_data
+
+
+def execute_snapshot_report(filters):
+	from frappe.database.duckdb.database import get_latest_sync
+
+	if conn := get_latest_sync("GL Entry"):
+		validate_filters(filters)
+		columns = get_columns()
+		data = get_data_duckdb(filters, conn)
+		return columns, data
+	else:
+		frappe.throw(_("Trial Balance requires {0} to be synced to DuckDB").format(frappe.bold("GL Entry")))
+
+
+def get_data_duckdb(filters, conn):
+	# accounts and all metadata via frappe.db — only GL Entry comes from DuckDB
+	accounts = frappe.db.sql(
+		"""select name, account_number, parent_account, account_name, root_type, report_type, is_group, lft, rgt
+		from `tabAccount` where company=%s order by lft""",
+		filters.company,
+		as_dict=True,
+	)
+	if not accounts:
+		return None
+
+	company_currency = filters.presentation_currency or erpnext.get_company_currency(filters.company)
+	ignore_is_opening = frappe.get_single_value("Accounts Settings", "ignore_is_opening_check_for_reporting")
+	accounts, accounts_by_name, parent_children_map = filter_accounts(accounts)
+
+	gl_entries_by_account = get_period_gl_entries_duckdb(conn, filters, ignore_is_opening)
+	opening_balances = get_opening_balances_duckdb(conn, filters, ignore_is_opening)
+
+	calculate_values(
+		accounts,
+		gl_entries_by_account,
+		opening_balances,
+		filters.get("show_net_values"),
+		ignore_is_opening=ignore_is_opening,
+	)
+	accumulate_values_into_parents(accounts, accounts_by_name)
+
+	data = prepare_data(accounts, filters, parent_children_map, company_currency)
+	return filter_out_zero_value_rows(
+		data, parent_children_map, show_zero_values=filters.get("show_zero_values")
+	)
+
+
+def _extra_gl_conditions(filters):
+	"""Returns (conditions, params) for optional shared GL Entry filters."""
+	conditions, params = [], []
+
+	if filters.get("cost_center"):
+		cc = get_cost_centers_with_children(filters.get("cost_center"))
+		conditions.append(f"cost_center IN ({', '.join(['?'] * len(cc))})")
+		params.extend(cc)
+
+	if filters.get("project"):
+		proj = filters.project if isinstance(filters.project, list) else [filters.project]
+		conditions.append(f"project IN ({', '.join(['?'] * len(proj))})")
+		params.extend(proj)
+
+	if frappe.db.count("Finance Book"):
+		company_fb = frappe.get_cached_value("Company", filters.company, "default_finance_book")
+		if filters.get("include_default_book_entries"):
+			if filters.get("finance_book") and company_fb and cstr(filters.finance_book) != cstr(company_fb):
+				frappe.throw(
+					_("To use a different finance book, please uncheck 'Include Default FB Entries'")
+				)
+			fb_list = [cstr(filters.get("finance_book")), cstr(company_fb), ""]
+		else:
+			fb_list = [cstr(filters.get("finance_book")), ""]
+		conditions.append(f"(finance_book IN ({', '.join(['?'] * len(fb_list))}) OR finance_book IS NULL)")
+		params.extend(fb_list)
+
+	for dim in get_accounting_dimensions(as_list=False):
+		if filters.get(dim.fieldname):
+			if frappe.get_cached_value("DocType", dim.document_type, "is_tree"):
+				filters[dim.fieldname] = get_dimension_with_children(
+					dim.document_type, filters.get(dim.fieldname)
+				)
+			vals = (
+				filters[dim.fieldname]
+				if isinstance(filters[dim.fieldname], list)
+				else [filters[dim.fieldname]]
+			)
+			conditions.append(f"{dim.fieldname} IN ({', '.join(['?'] * len(vals))})")
+			params.extend(vals)
+
+	return conditions, params
+
+
+def _fetch_gl_rows_duckdb(conn, conditions, params):
+	cols = [
+		"account",
+		"debit",
+		"credit",
+		"debit_in_account_currency",
+		"credit_in_account_currency",
+		"account_currency",
+	]
+	sql = f"""SELECT account, SUM(debit), SUM(credit),
+	                 SUM(debit_in_account_currency), SUM(credit_in_account_currency), account_currency
+	          FROM "tabGL Entry" WHERE {" AND ".join(conditions)}
+	          GROUP BY account, account_currency"""
+	return [frappe._dict(zip(cols, row, strict=False)) for row in conn.execute(sql, params).fetchall()]
+
+
+def get_period_gl_entries_duckdb(conn, filters, ignore_is_opening):
+	conditions = ["company = ?", "is_cancelled = 0", "posting_date >= ?", "posting_date <= ?"]
+	params = [filters.company, filters.from_date, filters.to_date]
+
+	if not ignore_is_opening:
+		conditions.append("is_opening = 'No'")
+	if not flt(filters.get("with_period_closing_entry_for_current_period")):
+		conditions.append("voucher_type != 'Period Closing Voucher'")
+
+	extra_cond, extra_params = _extra_gl_conditions(filters)
+	conditions.extend(extra_cond)
+	params.extend(extra_params)
+
+	entries = _fetch_gl_rows_duckdb(conn, conditions, params)
+	if filters.get("presentation_currency"):
+		convert_to_presentation_currency(entries, get_currency(filters))
+
+	gl_entries_by_account = {}
+	for entry in entries:
+		gl_entries_by_account.setdefault(entry.account, []).append(entry)
+	return gl_entries_by_account
+
+
+def get_opening_balances_duckdb(conn, filters, ignore_is_opening):
+	bs = _get_rootwise_opening_duckdb(conn, filters, "Balance Sheet", ignore_is_opening)
+	pl = _get_rootwise_opening_duckdb(conn, filters, "Profit and Loss", ignore_is_opening)
+	bs.update(pl)
+	return bs
+
+
+def _get_rootwise_opening_duckdb(conn, filters, report_type, ignore_is_opening):
+	accounting_dimensions = get_accounting_dimensions(as_list=False)
+	ignore_closing_balances = frappe.get_single_value("Accounts Settings", "ignore_account_closing_balance")
+	last_pcv = ""
+
+	if not ignore_closing_balances:
+		last_pcv = frappe.db.get_all(
+			"Period Closing Voucher",
+			filters={"docstatus": 1, "company": filters.company, "period_end_date": ("<", filters.from_date)},
+			fields=["period_end_date", "name"],
+			order_by="period_end_date desc",
+			limit=1,
+		)
+
+	if last_pcv:
+		# Account Closing Balance fetched via frappe (not GL Entry)
+		gle = get_opening_balance(
+			"Account Closing Balance",
+			filters,
+			report_type,
+			accounting_dimensions,
+			period_closing_voucher=last_pcv[0].name,
+			ignore_is_opening=ignore_is_opening,
+		)
+		if getdate(last_pcv[0].period_end_date) < getdate(add_days(filters.from_date, -1)):
+			start_date = add_days(last_pcv[0].period_end_date, 1)
+			gle += _get_gl_entry_opening_duckdb(
+				conn, filters, report_type, ignore_is_opening, start_date=start_date
+			)
+	else:
+		gle = _get_gl_entry_opening_duckdb(conn, filters, report_type, ignore_is_opening)
+
+	opening = frappe._dict()
+	for d in gle:
+		opening.setdefault(d.account, {"account": d.account, "opening_debit": 0.0, "opening_credit": 0.0})
+		opening[d.account]["opening_debit"] += flt(d.debit)
+		opening[d.account]["opening_credit"] += flt(d.credit)
+	return opening
+
+
+def _get_gl_entry_opening_duckdb(conn, filters, report_type, ignore_is_opening, start_date=None):
+	accounts = frappe.db.get_all("Account", filters={"report_type": report_type}, pluck="name")
+	if not accounts:
+		return []
+
+	conditions = ["company = ?", f"account IN ({', '.join(['?'] * len(accounts))})", "is_cancelled = 0"]
+	params = [filters.company, *accounts]
+
+	if start_date:
+		conditions.append("posting_date >= ? AND posting_date < ?")
+		params.extend([start_date, filters.from_date])
+		if not ignore_is_opening:
+			conditions.append("is_opening = 'No'")
+	elif not ignore_is_opening:
+		conditions.append("(posting_date < ? OR is_opening = 'Yes')")
+		params.append(filters.from_date)
+	else:
+		conditions.append("posting_date < ?")
+		params.append(filters.from_date)
+
+	if not filters.get("show_unclosed_fy_pl_balances") and report_type == "Profit and Loss":
+		conditions.append("posting_date >= ?")
+		params.append(filters.year_start_date)
+
+	if not flt(filters.get("with_period_closing_entry_for_opening")):
+		conditions.append("voucher_type != 'Period Closing Voucher'")
+
+	extra_cond, extra_params = _extra_gl_conditions(filters)
+	conditions.extend(extra_cond)
+	params.extend(extra_params)
+
+	gle = _fetch_gl_rows_duckdb(conn, conditions, params)
+	if filters.get("presentation_currency"):
+		convert_to_presentation_currency(gle, get_currency(filters))
+	return gle

erpnext/accounts/utils.py

@@ -1408,13 +1408,11 @@ def get_account_balances(accounts, company, finance_book=None, include_default_f
 def get_account_balances_coa(company: str, include_default_fb_balances: bool = False):
 	company_currency = frappe.get_cached_value("Company", company, "default_currency")
 
-	Account = DocType("Account")
-	account_list = (
-		frappe.qb.from_(Account)
-		.select(Account.name, Account.parent_account, Account.account_currency)
-		.where(Account.company == company)
-		.orderby(Account.lft)
-		.run(as_dict=True)
+	account_list = frappe.get_list(
+		"Account",
+		fields=["name", "parent_account", "account_currency"],
+		filters={"company": company},
+		order_by="lft",
 	)
 
 	account_balances_cc = {account.get("name"): 0 for account in account_list}
@@ -1424,9 +1422,8 @@ def get_account_balances_coa(company: str, include_default_fb_balances: bool = F
 	GLEntry = DocType("GL Entry")
 	precision = get_currency_precision()
 	get_ledger_balances_query = (
-		frappe.qb.from_(GLEntry)
+		frappe.get_query(GLEntry, fields=[GLEntry.account], ignore_permissions=False)
 		.select(
-			GLEntry.account,
 			(Sum(Round(GLEntry.debit, precision)) - Sum(Round(GLEntry.credit, precision))).as_("balance"),
 			(
 				Sum(Round(GLEntry.debit_in_account_currency, precision))
@@ -1436,7 +1433,7 @@ def get_account_balances_coa(company: str, include_default_fb_balances: bool = F
 		.groupby(GLEntry.account)
 	)
 
-	condition_list = [GLEntry.company == company, GLEntry.is_cancelled == 0]
+	conditions = [GLEntry.company == company, GLEntry.is_cancelled == 0]
 
 	default_finance_book = None
 
@@ -1444,12 +1441,9 @@ def get_account_balances_coa(company: str, include_default_fb_balances: bool = F
 		default_finance_book = frappe.get_cached_value("Company", company, "default_finance_book")
 
 	if default_finance_book:
-		condition_list.append(
-			(GLEntry.finance_book == default_finance_book) | (GLEntry.finance_book.isnull())
-		)
+		conditions.append((GLEntry.finance_book == default_finance_book) | (GLEntry.finance_book.isnull()))
 
-	for condition in condition_list:
-		get_ledger_balances_query = get_ledger_balances_query.where(condition)
+	get_ledger_balances_query = get_ledger_balances_query.where(Criterion.all(conditions))
 
 	ledger_balances = get_ledger_balances_query.run(as_dict=True)
 

erpnext/assets/dashboard_fixtures.py

@@ -1,190 +0,0 @@
-# Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
-# License: GNU General Public License v3. See license.txt
-
-import json
-
-import frappe
-from frappe import _
-from frappe.utils import get_date_str, nowdate
-
-from erpnext.accounts.dashboard_fixtures import _get_fiscal_year
-from erpnext.buying.dashboard_fixtures import get_company_for_dashboards
-
-
-def get_data():
-	fiscal_year = _get_fiscal_year(nowdate())
-
-	if not fiscal_year:
-		return frappe._dict()
-
-	year_start_date = get_date_str(fiscal_year.get("year_start_date"))
-	year_end_date = get_date_str(fiscal_year.get("year_end_date"))
-
-	return frappe._dict(
-		{
-			"dashboards": get_dashboards(),
-			"charts": get_charts(fiscal_year, year_start_date, year_end_date),
-			"number_cards": get_number_cards(fiscal_year, year_start_date, year_end_date),
-		}
-	)
-
-
-def get_dashboards():
-	return [
-		{
-			"name": "Asset",
-			"dashboard_name": "Asset",
-			"charts": [
-				{"chart": "Asset Value Analytics", "width": "Full"},
-				{"chart": "Category-wise Asset Value", "width": "Half"},
-				{"chart": "Location-wise Asset Value", "width": "Half"},
-			],
-			"cards": [
-				{"card": "Total Assets"},
-				{"card": "New Assets (This Year)"},
-				{"card": "Asset Value"},
-			],
-		}
-	]
-
-
-def get_charts(fiscal_year, year_start_date, year_end_date):
-	company = get_company_for_dashboards()
-	return [
-		{
-			"name": "Asset Value Analytics",
-			"chart_name": _("Asset Value Analytics"),
-			"chart_type": "Report",
-			"report_name": "Fixed Asset Register",
-			"is_custom": 1,
-			"group_by_type": "Count",
-			"number_of_groups": 0,
-			"is_public": 0,
-			"timespan": "Last Year",
-			"time_interval": "Yearly",
-			"timeseries": 0,
-			"filters_json": json.dumps(
-				{
-					"company": company,
-					"status": "In Location",
-					"filter_based_on": "Fiscal Year",
-					"from_fiscal_year": fiscal_year.get("name"),
-					"to_fiscal_year": fiscal_year.get("name"),
-					"period_start_date": year_start_date,
-					"period_end_date": year_end_date,
-					"date_based_on": "Purchase Date",
-					"group_by": "--Select a group--",
-				}
-			),
-			"type": "Bar",
-			"custom_options": json.dumps(
-				{
-					"type": "bar",
-					"barOptions": {"stacked": 1},
-					"axisOptions": {"shortenYAxisNumbers": 1},
-					"tooltipOptions": {},
-				}
-			),
-			"doctype": "Dashboard Chart",
-			"y_axis": [],
-		},
-		{
-			"name": "Category-wise Asset Value",
-			"chart_name": _("Category-wise Asset Value"),
-			"chart_type": "Report",
-			"report_name": "Fixed Asset Register",
-			"x_field": "asset_category",
-			"timeseries": 0,
-			"filters_json": json.dumps(
-				{
-					"company": company,
-					"status": "In Location",
-					"group_by": "Asset Category",
-					"asset_type": ["!=", "Existing Asset"],
-				}
-			),
-			"type": "Donut",
-			"doctype": "Dashboard Chart",
-			"y_axis": [
-				{
-					"parent": "Category-wise Asset Value",
-					"parentfield": "y_axis",
-					"parenttype": "Dashboard Chart",
-					"y_field": "asset_value",
-					"doctype": "Dashboard Chart Field",
-				}
-			],
-			"custom_options": json.dumps(
-				{"type": "donut", "height": 300, "axisOptions": {"shortenYAxisNumbers": 1}}
-			),
-		},
-		{
-			"name": "Location-wise Asset Value",
-			"chart_name": "Location-wise Asset Value",
-			"chart_type": "Report",
-			"report_name": "Fixed Asset Register",
-			"x_field": "location",
-			"timeseries": 0,
-			"filters_json": json.dumps(
-				{
-					"company": company,
-					"status": "In Location",
-					"group_by": "Location",
-					"asset_type": ["!=", "Existing Asset"],
-				}
-			),
-			"type": "Donut",
-			"doctype": "Dashboard Chart",
-			"y_axis": [
-				{
-					"parent": "Location-wise Asset Value",
-					"parentfield": "y_axis",
-					"parenttype": "Dashboard Chart",
-					"y_field": "asset_value",
-					"doctype": "Dashboard Chart Field",
-				}
-			],
-			"custom_options": json.dumps(
-				{"type": "donut", "height": 300, "axisOptions": {"shortenYAxisNumbers": 1}}
-			),
-		},
-	]
-
-
-def get_number_cards(fiscal_year, year_start_date, year_end_date):
-	return [
-		{
-			"name": "Total Assets",
-			"label": _("Total Assets"),
-			"function": "Count",
-			"document_type": "Asset",
-			"is_public": 1,
-			"show_percentage_stats": 1,
-			"stats_time_interval": "Monthly",
-			"filters_json": "[]",
-			"doctype": "Number Card",
-		},
-		{
-			"name": "New Assets (This Year)",
-			"label": _("New Assets (This Year)"),
-			"function": "Count",
-			"document_type": "Asset",
-			"is_public": 1,
-			"show_percentage_stats": 1,
-			"stats_time_interval": "Monthly",
-			"filters_json": json.dumps([["Asset", "creation", "between", [year_start_date, year_end_date]]]),
-			"doctype": "Number Card",
-		},
-		{
-			"name": "Asset Value",
-			"label": _("Asset Value"),
-			"function": "Sum",
-			"aggregate_function_based_on": "value_after_depreciation",
-			"document_type": "Asset",
-			"is_public": 1,
-			"show_percentage_stats": 1,
-			"stats_time_interval": "Monthly",
-			"filters_json": "[]",
-			"doctype": "Number Card",
-		},
-	]

erpnext/assets/doctype/asset/asset.js

@@ -93,6 +93,11 @@ frappe.ui.form.on("Asset", {
 		frappe.ui.form.trigger("Asset", "asset_type");
 		frm.toggle_display("next_depreciation_date", frm.doc.docstatus < 1);
 
+		if (frm.doc.docstatus < 1 && frm.doc.calculate_depreciation && frm.doc.is_fully_depreciated) {
+			// Is Fully Depreciated is read-only while depreciation is calculated, so keep it unchecked
+			frm.set_value("is_fully_depreciated", 0);
+		}
+
 		let has_create_buttons = false;
 		if (frm.doc.docstatus == 1) {
 			if (["Submitted", "Partially Depreciated"].includes(frm.doc.status)) {
@@ -142,7 +147,15 @@ frappe.ui.form.on("Asset", {
 						__("Actions")
 					);
 				}
-
+				if (frm.doc.status === "Fully Depreciated") {
+					frm.add_custom_button(
+						__("Asset Repair"),
+						function () {
+							frm.trigger("create_asset_repair");
+						},
+						__("Actions")
+					);
+				}
 				frm.add_custom_button(
 					__("Split Asset"),
 					function () {
@@ -726,6 +739,10 @@ frappe.ui.form.on("Asset", {
 
 	calculate_depreciation: function (frm) {
 		frm.toggle_reqd("finance_books", frm.doc.calculate_depreciation);
+		if (frm.doc.calculate_depreciation && frm.doc.is_fully_depreciated) {
+			// Is Fully Depreciated is read-only while depreciation is calculated, so keep it unchecked
+			frm.set_value("is_fully_depreciated", 0);
+		}
 		if (frm.doc.item_code && frm.doc.calculate_depreciation && frm.doc.net_purchase_amount) {
 			frm.trigger("set_finance_book");
 		} else {

erpnext/assets/doctype/asset/asset.json

@@ -450,10 +450,11 @@
   },
   {
    "default": "0",
+   "depends_on": "eval:(doc.asset_type == \"Existing Asset\" && !doc.calculate_depreciation) || doc.calculate_depreciation",
    "fieldname": "is_fully_depreciated",
    "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Is Fully Depreciated"
+   "label": "Is Fully Depreciated",
+   "read_only_depends_on": "eval:doc.calculate_depreciation"
   },
   {
    "depends_on": "eval:doc.docstatus > 0",

erpnext/assets/doctype/asset/asset.py

@@ -132,6 +132,10 @@ class Asset(AccountsController):
 		self.validate_gross_and_purchase_amount()
 		self.validate_finance_books()
 
+		if self.calculate_depreciation:
+			# Is Fully Depreciated is only applicable to manually entered existing assets
+			self.is_fully_depreciated = 0
+
 	def before_save(self):
 		self.total_asset_cost = self.net_purchase_amount + self.additional_asset_cost
 		self.status = self.get_status()

erpnext/assets/doctype/asset/test_asset.py

@@ -1391,6 +1391,47 @@ class TestDepreciationBasics(AssetSetup):
 		self.assertFalse(depr_schedule[1].journal_entry)
 		self.assertFalse(depr_schedule[2].journal_entry)
 
+	def test_depr_schedule_link_matches_at_currency_precision(self):
+		"""A Depreciation Schedule row whose amount carries more decimals than the
+		company currency (e.g. 25701.202 vs a JE debit of 25701.20) must still be
+		matched and stamped with the Journal Entry. Comparing at exact float
+		equality left the link NULL, so the scheduler treated the row as unposted
+		and created a duplicate Journal Entry on every run. Regression test for
+		JournalEntry.update_journal_entry_link_on_depr_schedule()."""
+		from unittest.mock import MagicMock, patch
+
+		from erpnext.accounts.doctype.journal_entry import journal_entry as journal_entry_module
+
+		posting_date = getdate("2021-06-01")
+		je = frappe.new_doc("Journal Entry")
+		je.name = "JE-DEPR-TEST"
+		je.finance_book = None
+		je.posting_date = posting_date
+
+		# JE debit is stored at company currency precision (2 dp)...
+		je_row = MagicMock()
+		je_row.debit = 25701.20
+		je_row.precision.return_value = 2
+
+		# ...while the schedule row amount carries a third decimal.
+		schedule_row = frappe._dict(
+			name="DS-ROW-1",
+			schedule_date=posting_date,
+			journal_entry=None,
+			depreciation_amount=25701.202,
+		)
+		asset = frappe._dict(name="ASSET-TEST")
+
+		with (
+			patch.object(journal_entry_module, "get_depr_schedule", return_value=[schedule_row]),
+			patch.object(frappe.db, "set_value") as mock_set_value,
+		):
+			je.update_journal_entry_link_on_depr_schedule(asset, je_row)
+
+		mock_set_value.assert_called_once_with(
+			"Depreciation Schedule", "DS-ROW-1", "journal_entry", "JE-DEPR-TEST"
+		)
+
 	def test_depr_entry_posting_when_depr_expense_account_is_an_expense_account(self):
 		"""Tests if the Depreciation Expense Account gets debited and the Accumulated Depreciation Account gets credited when the former's an Expense Account."""
 

erpnext/assets/doctype/asset_capitalization/asset_capitalization.py

@@ -100,6 +100,9 @@ class AssetCapitalization(StockController):
 		self.set_asset_values()
 		self.calculate_totals()
 		self.set_title()
+		# Asset Capitalization overrides validate() without calling super(), so the shared
+		# mandatory inventory dimension check must be invoked explicitly here.
+		self.validate_inventory_dimension_mandatory()
 
 	def on_update(self):
 		if self.stock_items:

erpnext/assets/doctype/asset_repair/asset_repair.js

@@ -84,6 +84,15 @@ frappe.ui.form.on("Asset Repair", {
 				};
 			};
 		}
+		if (frm.doc.asset) {
+			frappe.db.get_value("Asset", frm.doc.asset, "status").then(({ message }) => {
+				frm.set_df_property(
+					"capitalize_repair_cost",
+					"read_only",
+					message && message.status === "Fully Depreciated"
+				);
+			});
+		}
 	},
 
 	show_general_ledger: function (frm) {

erpnext/assets/doctype/asset_repair/asset_repair.json

@@ -130,7 +130,7 @@
    "fieldtype": "Link",
    "in_list_view": 1,
    "label": "Asset",
-   "link_filters": "[[\"Asset\",\"status\",\"not in\",[\"Work In Progress\",\"Capitalized\",\"Fully Depreciated\",\"Sold\",\"Scrapped\",\"Cancelled\"]]]",
+   "link_filters": "[[\"Asset\",\"status\",\"not in\",[\"Work In Progress\",\"Capitalized\",\"Sold\",\"Scrapped\",\"Cancelled\"]]]",
    "options": "Asset",
    "reqd": 1
   },
@@ -275,7 +275,7 @@
    "link_fieldname": "asset_repair"
   }
  ],
- "modified": "2026-02-06 14:57:54.257572",
+ "modified": "2026-06-20 15:43:54.943335",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Asset Repair",

erpnext/assets/doctype/asset_repair/asset_repair.py

@@ -70,12 +70,15 @@ class AssetRepair(AccountsController):
 		self.check_repair_status()
 
 	def validate_asset(self):
-		if self.asset_doc.status in ("Sold", "Fully Depreciated", "Scrapped"):
+		if self.asset_doc.status in ("Sold", "Scrapped"):
 			frappe.throw(
 				_("Asset {0} is in {1} status and cannot be repaired.").format(
 					get_link_to_form("Asset", self.asset), self.asset_doc.status
 				)
 			)
+		if self.asset_doc.get_status() == "Fully Depreciated":
+			self.capitalize_repair_cost = 0
+			self.increase_in_asset_life = 0
 
 	def validate_dates(self):
 		if self.completion_date and (getdate(self.failure_date) > getdate(self.completion_date)):

erpnext/bulk_transaction/doctype/bulk_transaction_log/bulk_transaction_log.py

@@ -30,10 +30,7 @@ class BulkTransactionLog(Document):
 	def load_from_db(self):
 		log_detail = qb.DocType("Bulk Transaction Log Detail")
 
-		has_records = frappe.db.sql(
-			"select exists (select * from `tabBulk Transaction Log Detail` where date = %s);",
-			(self.name,),
-		)[0][0]
+		has_records = frappe.db.exists("Bulk Transaction Log Detail", {"date": self.name})
 		if not has_records:
 			raise frappe.DoesNotExistError
 

erpnext/bulk_transaction/doctype/bulk_transaction_log/test_bulk_transaction_log.py

@@ -1,11 +1,76 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
-# See license.txt
-
-# import frappe
+# Copyright (c) 2024, Frappe Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
 
+import frappe
+from frappe.utils import nowtime, random_string
 
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestBulkTransactionLog(ERPNextTestSuite):
-	pass
+	def _make_log_doc(self, date):
+		# "Bulk Transaction Log" is a virtual doctype named by date; build the doc
+		# in-memory and drive load_from_db() directly to exercise the converted query.
+		doc = frappe.new_doc("Bulk Transaction Log")
+		doc.name = date
+		return doc
+
+	def _insert_detail(self, date, status="Success"):
+		detail = frappe.get_doc(
+			{
+				"doctype": "Bulk Transaction Log Detail",
+				"from_doctype": "Sales Order",
+				"to_doctype": "Sales Invoice",
+				"transaction_name": "_Test BTLD " + random_string(8),
+				"date": date,
+				"time": nowtime(),
+				"transaction_status": status,
+			}
+		)
+		# transaction_name is a Dynamic Link (options=from_doctype); the converted
+		# query never reads it, so skip link validation rather than create real txns.
+		detail.insert(ignore_permissions=True, ignore_links=True)
+		return detail
+
+	def test_load_raises_when_no_detail_rows(self):
+		# A date with zero Bulk Transaction Log Detail rows must not resolve to a log.
+		date = "2024-01-01"
+		self.assertFalse(
+			frappe.db.exists("Bulk Transaction Log Detail", {"date": date}),
+			"precondition: no detail rows for this date",
+		)
+
+		doc = self._make_log_doc(date)
+		self.assertRaises(frappe.DoesNotExistError, doc.load_from_db)
+
+	def test_load_succeeds_and_aggregates_after_detail_inserted(self):
+		date = "2024-02-02"
+
+		# Initially absent -> load_from_db must raise.
+		self.assertRaises(frappe.DoesNotExistError, self._make_log_doc(date).load_from_db)
+
+		# Insert detail rows for this date: 2 succeeded, 1 failed.
+		self._insert_detail(date, "Success")
+		self._insert_detail(date, "Success")
+		self._insert_detail(date, "Failed")
+
+		# Now the exists() check passes and load_from_db() populates aggregates.
+		doc = self._make_log_doc(date)
+		doc.load_from_db()
+
+		self.assertEqual(doc.date, date)
+		self.assertEqual(doc.succeeded, 2)
+		self.assertEqual(doc.failed, 1)
+		self.assertEqual(doc.log_entries, 3)
+
+	def test_load_isolated_per_date(self):
+		# Detail rows on a different date must not satisfy the lookup for our date.
+		other_date = "2024-03-03"
+		self._insert_detail(other_date, "Success")
+
+		target_date = "2024-04-04"
+		self.assertFalse(
+			frappe.db.exists("Bulk Transaction Log Detail", {"date": target_date}),
+			"target date has no rows; rows on another date must not leak in",
+		)
+		self.assertRaises(frappe.DoesNotExistError, self._make_log_doc(target_date).load_from_db)

erpnext/buying/doctype/purchase_order/purchase_order.py

@@ -270,6 +270,7 @@ class PurchaseOrder(BuyingController):
 					"ref_dn_field": "material_request_item",
 					"compare_fields": mri_compare_fields,
 					"is_child_table": True,
+					"allow_duplicate_prev_row_id": True,
 				},
 			}
 		)