pacman-debian 7.3.34 → 7.4.0

package/docs/en/architecture.md

@@ -7,26 +7,29 @@ src/
 ├── cli/
 │   ├── pacman.ts            # CLI argument parsing and dispatch
 │   ├── paclink.ts           # Virtual package link management
+│   ├── pactree.ts           # Dependency tree viewer
 │   ├── update-ca-trust.ts   # Arch-compat CA certificate updater
 │   ├── archlinux-java.ts    # Arch-compat Java alternatives manager
 │   └── fix_default.ts       # Arch-compat default JDK helper
 ├── core/                    # Package format parsers, dependency engine
 │   ├── ar.ts                # ar archive parser
-│   ├── tar.ts               # tar extractor
+│   ├── tar.ts               # tar extractor (with progress callback)
 │   ├── deb.ts               # .deb package parser
 │   ├── pkgfile.ts           # .pkg.tar.zst parser
 │   ├── compress.ts          # gz/xz decompression
 │   ├── control.ts           # debian control file parser
-│   └── deps.ts              # Dependency resolution engine
+│   ├── deps.ts              # Dependency resolution engine (verCmp built-in)
+│   ├── logger.ts            # File logger
+│   └── paclinks.ts          # Paclink mapping file (TS backend)
 ├── db/
 │   ├── localdb.ts           # Directory-based local package DB
 │   ├── database.ts          # DB wrapper with transactions
-│   └── dpkg-compat.ts       # dpkg status file read/write
+│   └── dpkg-compat.ts       # dpkg status file read/write (no dpkg command)
 ├── ops/
 │   ├── install.ts           # Package installation
 │   ├── remove.ts            # Package removal
 │   ├── query.ts             # All -Q queries
-│   └── upgrade.ts           # Sync + upgrade flow
+│   └── upgrade.ts           # Sync + upgrade flow (dpkg-aware)
 ├── repo/
 │   ├── repository.ts        # Repo sync, download, JSONL cache
 │   └── config.ts            # pacman.conf parser with Include support
@@ -34,10 +37,8 @@ src/
 │   └── setup.ts             # Interactive setup script
 ├── makepkg/
 │   ├── index.ts             # Main makepkg entry
-│   ├── pkgbuild.ts          # PKGBUILD parser
-│   ├── source.ts            # Source download/extraction
-│   ├── build.ts             # build()/package() execution
-│   └── printsrcinfo.ts      # .SRCINFO generation
+│   ├── pkgbuild.ts          # PKGBUILD parser (single-bash optimization)
+│   ├── build.ts             # build()/package() execution (VCS support)
 ├── ui/                      # User interface (prompt, formatting)
 └── index.ts                 # Entry point
 ```
@@ -50,7 +51,7 @@ lib/pac4deb/                 # libalpm C library
 │   └── alpm_list.h          # Linked list header
 └── src/
     ├── libalpm.c            # Core implementation (handle, db, pkg, JSON parser)
-    ├── stubs_manual.c       # ~200 stubs for rarely-used libalpm functions
+    ├── stubs_manual.c       # ~200 stubs for libalpm functions, idx search
     └── alpm_list.c          # Linked list implementation
 ```
 
@@ -58,7 +59,7 @@ lib/pac4deb/                 # libalpm C library
 
 ### Local database: `/var/lib/pacman-debian/local/`
 
-Directory-per-package format matching Arch Linux's local DB:
+Directory-per-package format:
 
 ```
 /var/lib/pacman-debian/local/
@@ -77,48 +78,109 @@ Directory-per-package format matching Arch Linux's local DB:
 Packages installed via `dpkg` or `apt` are read directly from
 `/var/lib/dpkg/status` at query time (mtime-cached). When `pacman-debian`
 installs a package, it writes a dpkg-compatible entry ensuring `apt` and `dpkg`
-still see the package.
+still see the package. **No `dpkg` command is ever invoked** — the status file
+is parsed directly, and file lists are read from `/var/lib/dpkg/info/*.list`.
 
 ### Repository cache: `/var/cache/pacman-debian/packages/`
 
 Each repository is cached in JSON Lines chunks (5000 packages per `.jsonl`
 file). During sync, a `packages.idx` index is also built — one line per
-package, sorted globally, with format `pkgname description\tprovides\tchunk\toffset`.
+package, sorted globally by name.
+
+**Idx format (v2, since 7.4.0):**
+```
+pkgname version\tdescription\tprovides\tchunk\toffset
+```
+
+The version is embedded directly in the idx line, allowing `findInRepo()` and
+search to return name + version without reading from the JSONL chunk.
 
 ```
 /var/cache/pacman-debian/packages/
-├── bookworm/
+├── trixie/
 │   ├── 00000.jsonl   # JSON Lines, ~5000 pkg per chunk
 │   ├── ...
-│   └── packages.idx  # Global sorted index (tabs, ~200KB)
+│   └── packages.idx  # Sorted index with version embedded
 └── ...
 ```
 
 #### Memory Index Cache
 
-`packages.idx` is cached in memory after first read, keyed by repo name + mtime:
+`packages.idx` is loaded **once** and cached permanently until
+`invalidateIdxCache()` is called. No stat/mtime checks on subsequent lookups:
 
 ```
 _idxCache = new Map<string, IdxEntry>();
-IdxEntry { lines: string[], mtime: number, providesIndex: Map<string, Array<{chunkFile, offset}>> }
+IdxEntry { lines: string[], providesIndex: Map<string, Array<{chunkFile, offset}>> }
+_pkgCache = new Map<string, RepoPkg>()  // LRU by chunkFile:offset
 ```
 
-- Subsequent `-S`/`-Ss`/`-Sl` operations read from memory, no disk I/O
-- `providesIndex` is an inverted index: `provides name → [{ chunkFile, offset }]`
-  - `findProvider()` does O(1) `Map.get()` for provides lookups
-- `pacman -Syy` clears the cache (`invalidateIdxCache()`)
-- After incremental sync, idx file mtime changes → auto reload
-
 ### Lookup Paths
 
 | Operation | Method | Why |
 |-----------|--------|-----|
-| `-S <pkg>` / `-Qo` | Binary search `packages.idx` → seek JSONL | O(log N), single line read |
-| `-Ss` | Line-scan `packages.idx` (name + desc) → seek JSONL | ~1.4MB scan, no JSON parse |
+| `-S <pkg>` / `-Qo` | Binary search `packages.idx` → seek JSONL | O(log N), single pread |
+| `-Ss` | Line-scan `packages.idx` (name + desc + version) | ~500KB scan, cached reads |
 | `-Sl` | Read `packages.idx` → seek each pkg | Lazy-load via index |
 | Dependency provides | Scan `packages.idx` provides field | Index-only, no JSON parse |
 | `-Qi` / `-Ql` | dpkg status or localdb | No cache involved |
 
+## Version Comparison (built-in, no dpkg dependency)
+
+Since **7.4.0**, the version comparison algorithm (`verCmp` in `src/core/deps.ts`)
+is a pure TypeScript port of dpkg's C implementation (`libdpkg/version.c`):
+
+```
+verrevcmp(a, b):
+  1. Skip non-digit prefixes, compare by character weight (order())
+     order(c):
+       digits → 0 (compared as integers below)
+       letters → ASCII value
+       '~' → -1 (sorts before everything)
+       other → charCode + 256
+  2. Skip leading zeros on digit groups
+  3. Compare digit groups as integers
+  4. Longer digit group wins
+```
+
+Epoch comparison: `epoch:a > epoch:b` → a wins (integer comparison).
+Revision comparison: same algorithm applied to the `-revision` suffix.
+
+This eliminates the only hard dependency on the `dpkg` command. The `dpkg`
+binary is now entirely optional — only the dpkg status file is read.
+
+## Paclink Mapping Backend
+
+Since **7.4.0**, Debian→Arch package name mappings are stored in
+`/var/lib/pacman-debian/paclinks` (plain text, sorted by virt name):
+
+```
+glibc libc6
+go golang-go
+libxtst libxtst6
+python python3
+```
+
+The C libalpm shim reads this file directly at startup via `load_paclinks()`,
+adding virtual names as `provides` on the corresponding dpkg packages.
+No recompilation is needed to add new mappings. Use `paclink -I` to
+initialize all common mappings from your installed Debian packages.
+
+## Sync Flow (Release-based for Debian repos)
+
+Since **7.4.0**, Debian repository sync follows apt's approach:
+
+1. Download `InRelease` / `Release` file with `If-Modified-Since`
+2. If 304 → repo is up to date
+3. Parse SHA256 hashes from Release file
+4. For each component (`main`, `universe`, etc.), compare SHA256 with cached
+   values from the previous sync
+5. Only download new `Packages.xz`/`Packages.gz` when SHA256 differs
+6. Save new SHA256 in `.info` for next sync
+
+This eliminates false `notModified` returns from `If-Modified-Since` on
+Packages files that haven't changed but where the Release metadata is newer.
+
 ## Dependency Engine
 
 The dependency resolver (`src/core/deps.ts`) handles:
@@ -130,41 +192,29 @@ The dependency resolver (`src/core/deps.ts`) handles:
 - BFS resolution with pre-loaded DB state
 - Conflict detection across installed and to-be-installed packages
 - System package protection (glibc, libc6, etc.)
-
-- File validation: installed packages with no real files on disk are
-  considered NOT installed, forcing re-download.
-- Explicit targets always have their dependencies processed even if the
-  target itself is already installed.
-- Queue uses `shift()` to pop processed items, preventing memory accumulation.
+- dpkg-aware upgrade scanning: also checks apt-installed packages against
+  Debian repo updates
 
 ### Performance Optimizations
 
 | Technique | Description |
 |-----------|-------------|
-| **idx memory cache** | `findInRepo()` binary search on `_idxCache.lines[]` in memory |
+| **idx memory cache** | `findInRepo()` binary search on `_idxCache.lines[]` in memory (loaded once) |
 | **provides inverted index** | `findProvider()` does `Map.get()` O(1) |
 | **BFS + cursor** | Dependency queue uses index pointer instead of `shift()` |
 | **batch head-tail scan** | Binary searches sorted idx from both ends simultaneously |
 | **keep-alive HTTP** | Shared `https.Agent({ keepAlive: true, maxSockets: 8 })` |
 | **async .gz decompress** | Non-blocking zlib with callback |
 | **304 conditional requests** | Sync sends `If-Modified-Since`, skip unchanged repos |
-
-### Delete Dependency Handling
-
-| Operation | Logic |
-|-----------|-------|
-| `-R` | Remove specified package only |
-| `-Rs` | Remove package + recursive orphan find, reverse-topological order |
-| `-Rc` | Cascade: find all packages requiring the target |
-| `-Rsc` | Recursive + cascade combination |
-| `-Rn` | Backup conffiles as `.dpkg-old`, then remove |
-
-Removal auto-sorts dependents first (leaves before roots).
+| **Release-based SHA256 check** | Only download Packages when content actually changed |
+| **Package read cache** | `_pkgCache` caches `readPkgAt()` results by chunk+offset |
+| **Single-bash PKGBUILD parse** | Source once, export all variables (was 35 separate forks) |
 
 ## Repository Support
 
 - **Debian/Ubuntu**: Reads `Packages.gz` / `Packages.xz` from standard
   repository indices. Supports `$repo`/`$arch` variable substitution.
+  Release-based SHA256 validation before downloading.
 - **Arch Linux**: Reads `db.tar.gz` from Arch-compatible repositories.
   Downloaded `.pkg.tar.zst` files are extracted and installed.
 - **Arch ARM**: Binary packages require glibc 2.38+ — Debian 12 ships 2.36.
@@ -174,12 +224,26 @@ Removal auto-sorts dependents first (leaves before roots).
 
 Key features:
 
-- **Performance**: `packages.idx` index enables sub-second single-package lookup.
+- **Performance**: `packages.idx` with embedded version enables sub-100ms
+  search across 3000+ packages; idx is loaded once and cached in memory.
+- **Zero dpkg dependency**: Version comparison algorithm ported from libdpkg,
+  dpkg status read directly, no `dpkg` command required.
 - **Parallel sync**: Repos sync concurrently with per-repo progress display.
+- **64-bit indexed binary search**: Sorted idx enables O(log N) single-package lookup.
 - **i18n**: Full Chinese and English localization via `$LANG` detection.
 - **Color**: Matching official pacman color scheme.
 - **Root check**: Query commands work without root; write operations require `sudo`.
-- **Link system** (`paclink`): Debian→Arch virtual package name mappings.
+- **Link system** (`paclink`): Debian→Arch virtual package name mappings stored
+  in file backend, read by C shim at startup.
+- **makepkg**: VCS source support (git, hg), parallel downloads, progress bars.
+- **Release-based sync**: SHA256-validated Debian repo updates (like apt).
+- **XferCommand**: Custom download commands (aria2c, curl, wget).
+- **CheckSpace**: Configurable disk space verification before install.
+- **IgnorePkg / NoUpgrade / NoExtract**: Standard pacman config options supported.
+- **VerbosePkgLists**: Tabular package listing with version, repo, size columns.
+- **CleanMethod**: `KeepInstalled` / `KeepCurrent` cache cleaning policy.
+- **Downgrade protection**: Version comparison handles epochs, revisions, `~`
+  (pre-release), and all dpkg version semantics.
 
 Key limitations:
 

package/docs/en/pactree.md

@@ -0,0 +1,42 @@
+# pactree — Package Dependency Tree Viewer
+
+`pactree` displays the dependency tree of a package, showing what it depends
+on (forward) or what depends on it (reverse). It queries all available sources:
+local database, dpkg status, and repository indexes.
+
+## Usage
+
+```
+pactree [options] <package>
+```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `-r`, `--reverse` | Show reverse dependencies (what depends on this package) |
+| `-d`, `--depth` | Maximum tree depth (default: unlimited) |
+| `-s`, `--sync` | Show version numbers |
+| `-h`, `--help` | Show help |
+
+## Examples
+
+```bash
+# Show what glibc depends on
+pactree glibc
+
+# Show what depends on glibc (reverse)
+pactree -r glibc
+
+# Limit depth to 2
+pactree -d 2 python3
+
+# Show with versions
+pactree -s mesa
+```
+
+## Notes
+
+- Circular dependencies are detected and marked with `(circular)`
+- Missing packages are marked with `(not found)`
+- The tree queries dpkg status, pacman-debian local DB, and sync repos

package/docs/en/yay-aur.md

@@ -10,6 +10,7 @@ modification. It reads:
   pacman-debian
 - dpkg status (`/var/lib/dpkg/status`) — system packages from apt/dpkg
 - Sync databases (`/var/cache/pacman-debian/packages/*/` — JSONL chunks)
+- Paclink mappings (`/var/lib/pacman-debian/paclinks`) — Debian→Arch name map
 
 Over 200 stubs are provided for rarely-used functions.
 
@@ -18,14 +19,17 @@ Over 200 stubs are provided for rarely-used functions.
 - **packages.idx binary search (C)**: `alpm_db_get_pkg` and
   `alpm_find_dbs_satisfier` use binary search on the sorted index, then read
   a single JSONL line by byte offset — no full JSONL loading.
+- **Paclink file backend**: Since 7.4.0, mappings are read from
+  `/var/lib/pacman-debian/paclinks` (sorted text file) by `load_paclinks()`.
+  No hardcoded table or recompilation needed. `libc6 → glibc`,
+  `libxtst6 → libxtst`, `golang-go → go`, etc. are resolved at startup.
 - **Auto-register sync DBs**: `ensure_syncdbs` scans
   `/var/cache/pacman-debian/packages/` on first `alpm_get_syncdbs`,
   registering all available repos lazily.
 - **Package DB pointer**: `pkg_internal.db` field tracks owning database;
   `alpm_pkg_get_db` returns it, preventing `DB().Name()` nil dereference.
 - **idx-based search**: `alpm_db_search` scans index lines for pattern
-  matching instead of loading all packages. ~1.5s for -Ss with 6 repos / 15k
-  packages.
+  matching instead of loading all packages. Sub-second for -Ss with 7 repos.
 - **dpkg Provides parsing**: `load_dpkg_status` reads the `Provides:` field
   from dpkg status, so Debian packages that declare virtual names
   (e.g. `7zip` → `p7zip`) are discoverable by yay via
@@ -34,10 +38,10 @@ Over 200 stubs are provided for rarely-used functions.
   database after sync DBs, matching both package names and provides.
 - **find_in_idx provides scan**: After binary search by package name fails,
   scans the `provides` column of `packages.idx` for sync DB provides.
-- **dpkg -S fallback**: For `lib*.so` SONAMEs not found anywhere, forks
-  `dpkg -S` to locate the owning Debian package at runtime.
 - **Debian alternatives**: Checks `/etc/alternatives/` for `sh`, `awk`, `vi`,
   `editor` etc. and adds virtual provides to the owning package.
+- **alpm_pkg_find**: Implemented (no longer a stub), searches linked list by
+  name for yay's dependency resolution.
 
 ### Build
 
@@ -56,9 +60,9 @@ sudo apt install golang-go
 git clone https://aur.archlinux.org/yay.git /tmp/yay
 cd /tmp/yay && go build -o /usr/local/bin/yay
 
-# Use with pacman-debian (PACMAN env var detected automatically)
+# Use with pacman-debian
 yay -Ss ponysay
-sudo -E yay -S ponysay
+sudo pacman -S jdk21-openjdk   # yay also works for sync packages
 ```
 
 Note: AUR packages that depend on `python` (not `python3`) are resolved

package/docs/zh-CN/pactree.md

@@ -0,0 +1,41 @@
+# pactree — 包依赖树查看器
+
+显示包的依赖树（正向：依赖了什么，反向：被什么依赖）。查询所有可用来源：
+本地数据库、dpkg 状态和仓库索引。
+
+## 用法
+
+```
+pactree [选项] <包名>
+```
+
+## 选项
+
+| 选项 | 说明 |
+|------|------|
+| `-r`, `--reverse` | 显示反向依赖（谁依赖这个包） |
+| `-d`, `--depth` | 最大树深度（默认不限） |
+| `-s`, `--sync` | 显示版本号 |
+| `-h`, `--help` | 显示帮助 |
+
+## 示例
+
+```bash
+# 查看 glibc 依赖了什么
+pactree glibc
+
+# 查看谁依赖 glibc（反向）
+pactree -r glibc
+
+# 限制深度为 2
+pactree -d 2 python3
+
+# 显示版本
+pactree -s mesa
+```
+
+## 说明
+
+- 循环依赖会被检测并标记 `(circular)`
+- 找不到的包标记 `(not found)`
+- 查询范围包括 dpkg 状态、pacman-debian 本地数据库和同步仓库

package/lib/pac4deb/src/libalpm.c

@@ -380,6 +380,45 @@ static alpm_list_t *load_dpkg_status(const char *path) {
  	return pkgs;
  }
 
+/* Read paclink mappings from /var/lib/pacman-debian/paclinks.
+   Format: <virt_name> <deb_package_name>, one per line, sorted by virt. */
+static void load_paclinks(alpm_list_t *pkgs) {
+	char path[4096];
+	snprintf(path, sizeof(path), "%s/paclinks", DB_DIR);
+	FILE *fp = fopen(path, "r");
+	if (!fp) return;
+	char line[512];
+	while (fgets(line, sizeof(line), fp)) {
+		if (line[0] == '#' || line[0] == '\n' || line[0] == '\r') continue;
+		char virt[256] = {0}, deb[256] = {0};
+		if (sscanf(line, "%255s %255s", virt, deb) != 2) continue;
+		for (alpm_list_t *it = pkgs; it; it = it->next) {
+			pkg_internal *p = it->data;
+			if (strcmp(p->name, deb) != 0) continue;
+			if (p->provides && *p->provides) {
+				char tmp[512]; snprintf(tmp, sizeof(tmp), ",%s,", p->provides);
+				char needle[64]; snprintf(needle, sizeof(needle), ",%s,", virt);
+				if (strstr(tmp, needle)) break;
+			}
+			size_t old = p->provides ? strlen(p->provides) : 0;
+			size_t add = strlen(virt);
+			char *nv = malloc(old + add + 3);
+			if (!nv) break;
+			if (p->provides) {
+				memcpy(nv, p->provides, old);
+				nv[old] = ',';
+				memcpy(nv + old + 1, virt, add + 1);
+				free(p->provides);
+			} else {
+				memcpy(nv, virt, add + 1);
+			}
+			p->provides = nv;
+			break;
+		}
+	}
+	fclose(fp);
+}
+
 /* Resolve Debian alternatives: readlink /bin/<cmd> to find real binary,
    then map its package name back to the virtual provide name.
    e.g. /bin/sh -> dash -> add provides "sh" on the dash pkg_internal */
@@ -474,39 +513,7 @@ static void add_alternative_provides(alpm_list_t *pkgs) {
 		}
 	}
 
-	/* Map common Arch package names to Debian equivalents.
-	   These are packages that don't map 1:1 by name but provide equivalent functionality. */
-	static const char *pkg_map[][2] = {
-		{"ca-certificates", "ca-certificates-utils"},
-		{"python3", "python"},
-		{NULL, NULL}
-	};
-	for (int i = 0; pkg_map[i][0]; i++) {
-		for (alpm_list_t *it = pkgs; it; it = it->next) {
-			pkg_internal *p = it->data;
-			if (strcmp(p->name, pkg_map[i][0]) != 0) continue;
-			const char *virt = pkg_map[i][1];
-			if (p->provides && *p->provides) {
-				char tmp[512]; snprintf(tmp, sizeof(tmp), ",%s,", p->provides);
-				char needle[64]; snprintf(needle, sizeof(needle), ",%s,", virt);
-				if (strstr(tmp, needle)) break;
-			}
-			size_t old = p->provides ? strlen(p->provides) : 0;
-			size_t add = strlen(virt);
-			char *nv = malloc(old + add + 3);
-			if (!nv) break;
-			if (p->provides) {
-				memcpy(nv, p->provides, old);
-				nv[old] = ',';
-				memcpy(nv + old + 1, virt, add + 1);
-				free(p->provides);
-			} else {
-				memcpy(nv, virt, add + 1);
-			}
-			p->provides = nv;
-			break;
-		}
-	}
+	load_paclinks(pkgs);
 }
 
 /* Load local database: our packages + dpkg status */

package/lib/pac4deb/src/stubs_manual.c

@@ -425,7 +425,17 @@ void *alpm_pkg_get_checkdepends(alpm_pkg_t *p) { (void)p; return NULL; }
 void *alpm_pkg_get_makedepends(alpm_pkg_t *p) { (void)p; return NULL; }
 void *alpm_pkg_get_xdata(alpm_pkg_t *p) { (void)p; return NULL; }
 void *alpm_pkg_get_handle(alpm_pkg_t *p) { (void)p; return NULL; }
-alpm_pkg_t *alpm_pkg_find(void *list, const char *name) { (void)list; (void)name; return NULL; }
+alpm_pkg_t *alpm_pkg_find(void *list, const char *name) { 
+	if (!list || !name) return NULL;
+	alpm_list_t *it;
+	for (it = (alpm_list_t *)list; it; it = it->next) {
+		alpm_pkg_t *p = (alpm_pkg_t *)it->data;
+		if (!p) continue;
+		const char *n = alpm_pkg_get_name(p);
+		if (n && strcmp(n, name) == 0) return p;
+	}
+	return NULL; 
+}
 int alpm_pkg_should_ignore(alpm_handle_t *h, alpm_pkg_t *p) { (void)h; (void)p; return 0; }
 int alpm_pkg_download_size(alpm_pkg_t *p) { (void)p; return 0; }
 int alpm_filelist_contains(void *fl, const char *path) { (void)fl; (void)path; return 0; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacman-debian",
-  "version": "7.3.34",
+  "version": "7.4.0",
   "description": "A Debian/Ubuntu package manager using Arch Linux pacman syntax. Manages .deb packages at dpkg level, supports Arch .pkg.tar.zst, AUR helpers (yay), and makepkg. Configurable multi-repo setup.",
   "pacmanVersion": "7.1.0",
   "main": "dist/index.js",
@@ -31,7 +31,8 @@
     "paclink": "dist/cli/paclink.js",
     "update-ca-trust": "dist/cli/update-ca-trust.js",
     "archlinux-java": "dist/cli/archlinux-java.js",
-    "fix_default": "dist/cli/fix_default.js"
+    "fix_default": "dist/cli/fix_default.js",
+    "pactree": "dist/cli/pactree.js"
   },
   "scripts": {
     "build": "tsc && make -s -C lib/pac4deb",

package/resources/pacman.conf.template

@@ -8,11 +8,25 @@ Architecture = auto
 #HookDir     = /etc/pacman.d/hooks/
 HoldPkg     = pacman glibc
 ParallelDownloads = 5
-#CheckSpace
+CheckSpace
 Color
 #VerbosePkgLists
 #DownloadUser = alpm
 
+# Custom download command (replace built-in HTTP with external tool)
+#XferCommand = /usr/bin/curl -L -C - -f -o %o %u
+#XferCommand = /usr/bin/wget --passive-ftp -c -O %o %u
+
+# CleanMethod: KeepInstalled (default) or KeepCurrent
+#CleanMethod = KeepInstalled
+
+# Ignore these packages during upgrade
+#IgnorePkg =
+#IgnoreGroup =
+
+# Protect files from overwrite during install
+#NoUpgrade   =
+#NoExtract   =
+
 SigLevel    = Never
 LocalFileSigLevel = Optional
-#RemoteFileSigLevel = Required