Release 2026.08.06

.gitignore

@@ -73,12 +73,13 @@ debug.log
 *.pot
 
 # Package artifacts
-*.pkg.tar.zst
+*.pkg.tar.*
 distro-packages/**/.SRCINFO
 distro-packages/**/*.log
 distro-packages/*/*/cthulhu/
 distro-packages/*/*/cthulhu-git/
 distro-packages/*/*/pkg/
+distro-packages/*/*/src/
 
 # Generated makefiles (should not be committed)
 Makefile

distro-packages/Arch-Linux/cthulhu-git/PKGBUILD

@@ -65,7 +65,8 @@ optdepends=(
   'python-pillow: Image processing for OCR'
   'python-pytesseract: Python wrapper for Tesseract OCR engine'
   'tesseract: OCR engine for text recognition'
-
+)
+optdepends_x86_64=(
   # The helper is x86_64-only, but this package is architecture-independent.
   'cthulhu-wine-access-git: Wine, Proton, NVDA Controller, and Tolk integration'
 )

distro-packages/Arch-Linux/cthulhu-wine-access/PKGBUILD

@@ -0,0 +1,39 @@
+# Maintainer: Storm Dragon <storm_dragon@stormux.org>
+# shellcheck shell=bash disable=SC2034,SC2154,SC2164
+
+pkgname=cthulhu-wine-access
+pkgver=2026.08.06
+pkgrel=1
+pkgdesc="Optional Wine and Proton accessibility bridge for Cthulhu"
+url="https://git.stormux.org/storm/cthulhu"
+arch=(x86_64)
+license=(LGPL-2.1-or-later)
+depends=(
+  "cthulhu=${pkgver}"
+  glib2
+  wine
+)
+makedepends=(
+  cmake
+  git
+  meson
+)
+source=("git+https://git.stormux.org/storm/cthulhu.git#tag=${pkgver}")
+sha512sums=('SKIP')
+options=(!lto)
+
+build() {
+  cd cthulhu
+  arch-meson _build -Dwine-access=enabled
+  meson compile -C _build
+}
+
+package() {
+  cd cthulhu
+  install -Dm755 _build/cthulhu-wine-access.exe \
+    "$pkgdir/usr/libexec/cthulhu/wine/cthulhu-wine-access.exe"
+  install -Dm755 _build/cthulhu-wine-access.exe.so \
+    "$pkgdir/usr/libexec/cthulhu/wine/cthulhu-wine-access.exe.so"
+}
+
+# vim:set sw=2 sts=-1 et:

distro-packages/Arch-Linux/cthulhu/PKGBUILD

@@ -3,7 +3,7 @@
 
 pkgbase=cthulhu
 pkgname=cthulhu
-pkgver=2026.05.25
+pkgver=2026.08.06
 pkgrel=1
 pkgdesc="Desktop-agnostic screen reader with plugin system, forked from Orca"
 url="https://git.stormux.org/storm/cthulhu"
@@ -63,6 +63,9 @@ optdepends=(
   'python-pytesseract: Python wrapper for Tesseract OCR engine'
   'tesseract: OCR engine for text recognition'
 )
+optdepends_x86_64=(
+  'cthulhu-wine-access: Wine, Proton, NVDA Controller, and Tolk integration'
+)
 makedepends=(
   git
   meson
@@ -72,7 +75,7 @@ sha512sums=('SKIP')
 
 build() {
   cd cthulhu
-  arch-meson _build
+  arch-meson _build -Dwine-access=disabled
   meson compile -C _build
 }
 

distro-packages/Slackware/cthulhu.SlackBuild

@@ -6,7 +6,7 @@
 cd "$(dirname "$0")" ; CWD=$(pwd)
 
 PRGNAM=cthulhu
-VERSION=${VERSION:-2026.05.25}
+VERSION=${VERSION:-2026.08.06}
 BUILD=${BUILD:-1}
 TAG=storm
 PKGTYPE=txz

distro-packages/Slint/cthulhu-info

@@ -1,5 +1,5 @@
 PRGNAM="cthulhu"
-VERSION="2026.05.25"
+VERSION="2026.08.06"
 HOMEPAGE="https://git.stormux.org/storm/cthulhu"
 DOWNLOAD="https://git.stormux.org/storm/cthulhu.git"
 MD5SUM="SKIP"

distro-packages/Slint/cthulhu.SlackBuild

@@ -6,7 +6,7 @@
 cd "$(dirname "$0")" ; CWD=$(pwd)
 
 PRGNAM=cthulhu
-VERSION=${VERSION:-2026.05.25}
+VERSION=${VERSION:-2026.08.06}
 BUILD=${BUILD:-1}
 TAG=storm
 PKGTYPE=txz

meson.build

@@ -1,5 +1,5 @@
 project('cthulhu',
-  version: '2026.07.18',
+  version: '2026.08.06',
   meson_version: '>= 1.0.0',
 )
 

set-version.sh

@@ -59,11 +59,12 @@ fi
 cthulhuVersionFile="${scriptDir}/src/cthulhu/cthulhuVersion.py"
 mesonFile="${scriptDir}/meson.build"
 pkgbuildFile="${scriptDir}/distro-packages/Arch-Linux/cthulhu/PKGBUILD"
+winePkgbuildFile="${scriptDir}/distro-packages/Arch-Linux/cthulhu-wine-access/PKGBUILD"
 slackwareBuildFile="${scriptDir}/distro-packages/Slackware/cthulhu.SlackBuild"
 slintBuildFile="${scriptDir}/distro-packages/Slint/cthulhu.SlackBuild"
 slintInfoFile="${scriptDir}/distro-packages/Slint/cthulhu-info"
 
-for path in "$cthulhuVersionFile" "$mesonFile" "$pkgbuildFile" "$slackwareBuildFile" "$slintBuildFile" "$slintInfoFile"; do
+for path in "$cthulhuVersionFile" "$mesonFile" "$pkgbuildFile" "$winePkgbuildFile" "$slackwareBuildFile" "$slintBuildFile" "$slintInfoFile"; do
   if [[ ! -f "$path" ]]; then
     echo "Error: Missing file: $path" >&2
     exit 1
@@ -75,6 +76,8 @@ sed -i "s/^codeName = \".*\"/codeName = \"${codeNameValue}\"/" "$cthulhuVersionF
 sed -i "s/^  version: '.*',/  version: '${fullVersion}',/" "$mesonFile"
 sed -i "s/^pkgver=.*/pkgver=${pythonVersion}/" "$pkgbuildFile"
 sed -i "s/^pkgrel=.*/pkgrel=1/" "$pkgbuildFile"
+sed -i "s/^pkgver=.*/pkgver=${pythonVersion}/" "$winePkgbuildFile"
+sed -i "s/^pkgrel=.*/pkgrel=1/" "$winePkgbuildFile"
 sed -i "s/^VERSION=\${VERSION:-.*}/VERSION=\${VERSION:-${pythonVersion}}/" "$slackwareBuildFile"
 sed -i "s/^VERSION=\${VERSION:-.*}/VERSION=\${VERSION:-${pythonVersion}}/" "$slintBuildFile"
 sed -i "s/^VERSION=\".*\"/VERSION=\"${pythonVersion}\"/" "$slintInfoFile"
@@ -99,6 +102,14 @@ if ! rg -q "^pkgrel=1$" "$pkgbuildFile"; then
   echo "Error: Failed to reset pkgrel in ${pkgbuildFile}" >&2
   exit 1
 fi
+if ! rg -q "^pkgver=${pythonVersion}$" "$winePkgbuildFile"; then
+  echo "Error: Failed to update ${winePkgbuildFile}" >&2
+  exit 1
+fi
+if ! rg -q "^pkgrel=1$" "$winePkgbuildFile"; then
+  echo "Error: Failed to reset pkgrel in ${winePkgbuildFile}" >&2
+  exit 1
+fi
 if ! rg -q "^VERSION=\\\$\\{VERSION:-${pythonVersion}\\}$" "$slackwareBuildFile"; then
   echo "Error: Failed to update ${slackwareBuildFile}" >&2
   exit 1
@@ -116,6 +127,7 @@ echo "Updated version to ${fullVersion} in:" \
   "${cthulhuVersionFile}" \
   "${mesonFile}" \
   "${pkgbuildFile}" \
+  "${winePkgbuildFile}" \
   "${slackwareBuildFile}" \
   "${slintBuildFile}" \
   "${slintInfoFile}"

tests/test_arch_pkgbuild_optional_wine.py

@@ -1,28 +1,40 @@
+import re
 import unittest
 from pathlib import Path
 
 
 class ArchPkgbuildOptionalWineTests(unittest.TestCase):
     @classmethod
-    def setUpClass(cls):
+    def setUpClass(cls) -> None:
         repository = Path(__file__).resolve().parents[1]
+        cls.repository = repository
+        versionContents = (
+            repository / "src" / "cthulhu" / "cthulhuVersion.py"
+        ).read_text(encoding="utf-8")
+        versionMatch = re.search(r'(?m)^version = "([^"]+)"$', versionContents)
+        if versionMatch is None:
+            raise AssertionError("Unable to read the current Cthulhu version")
+        cls.releaseVersion = versionMatch.group(1)
         cls.pkgbuilds = [
             repository / "distro-packages" / "Arch-Linux" / name / "PKGBUILD"
             for name in ("cthulhu", "cthulhu-git")
         ]
         cls.helperPkgbuilds = [
             repository / "distro-packages" / "Arch-Linux" / name / "PKGBUILD"
-            for name in ("cthulhu-wine-access-git",)
+            for name in ("cthulhu-wine-access", "cthulhu-wine-access-git")
         ]
 
-    def test_main_packages_disable_wine_helper_build(self):
+    @staticmethod
-        stableContents = self.pkgbuilds[0].read_text(encoding="utf-8")
+    def _array_contents(contents: str, arrayName: str) -> str:
-        self.assertNotIn("wine-access", stableContents)
+        return contents.split(f"{arrayName}=(", 1)[1].split(")", 1)[0]
 
-        gitContents = self.pkgbuilds[1].read_text(encoding="utf-8")
+    def test_main_packages_disable_wine_helper_build(self) -> None:
-        self.assertIn("-Dwine-access=disabled", gitContents)
+        for pkgbuild in self.pkgbuilds:
+            with self.subTest(pkgbuild=pkgbuild):
+                contents = pkgbuild.read_text(encoding="utf-8")
+                self.assertIn("-Dwine-access=disabled", contents)
 
-    def test_main_packages_do_not_depend_on_wine(self):
+    def test_main_packages_do_not_depend_on_wine(self) -> None:
         for pkgbuild in self.pkgbuilds:
             with self.subTest(pkgbuild=pkgbuild):
                 contents = pkgbuild.read_text(encoding="utf-8")
@@ -34,35 +46,81 @@ class ArchPkgbuildOptionalWineTests(unittest.TestCase):
                 }
                 self.assertNotIn("wine", dependencyLines)
 
-    def test_main_packages_advertise_matching_optional_helper(self):
+    def test_main_packages_advertise_matching_optional_helper(self) -> None:
         stableContents = self.pkgbuilds[0].read_text(encoding="utf-8")
-        self.assertNotIn("cthulhu-wine-access", stableContents)
+        self.assertIn(
+            "'cthulhu-wine-access: Wine, Proton, NVDA Controller, and Tolk integration'",
+            self._array_contents(stableContents, "optdepends_x86_64"),
+        )
+        self.assertNotIn(
+            "cthulhu-wine-access",
+            self._array_contents(stableContents, "optdepends"),
+        )
 
         gitContents = self.pkgbuilds[1].read_text(encoding="utf-8")
         self.assertIn(
             "'cthulhu-wine-access-git: Wine, Proton, NVDA Controller, and Tolk integration'",
-            gitContents,
+            self._array_contents(gitContents, "optdepends_x86_64"),
+        )
+        self.assertNotIn(
+            "cthulhu-wine-access-git",
+            self._array_contents(gitContents, "optdepends"),
         )
-        self.assertNotIn("optdepends_x86_64", gitContents)
 
-    def test_stable_packages_use_current_release_version(self):
+    def test_stable_packages_use_current_release_version(self) -> None:
-        contents = self.pkgbuilds[0].read_text(encoding="utf-8")
+        for pkgbuild in (self.pkgbuilds[0], self.helperPkgbuilds[0]):
-        self.assertRegex(contents, r"(?m)^pkgver=2026\.05\.25$")
+            with self.subTest(pkgbuild=pkgbuild):
+                contents = pkgbuild.read_text(encoding="utf-8")
+                self.assertRegex(
+                    contents,
+                    rf"(?m)^pkgver={re.escape(self.releaseVersion)}$",
+                )
 
-    def test_optional_helper_packages_own_the_wine_dependency(self):
+    def test_release_metadata_uses_current_release_version(self) -> None:
+        mesonContents = (self.repository / "meson.build").read_text(encoding="utf-8")
+        self.assertRegex(
+            mesonContents,
+            rf"(?m)^  version: '{re.escape(self.releaseVersion)}(?:-[^']+)?',$",
+        )
+
+        expectedSlackwareVersion = f"VERSION=${{VERSION:-{self.releaseVersion}}}"
+        for relativePath in (
+            ("distro-packages", "Slackware", "cthulhu.SlackBuild"),
+            ("distro-packages", "Slint", "cthulhu.SlackBuild"),
+        ):
+            with self.subTest(relativePath=relativePath):
+                contents = self.repository.joinpath(*relativePath).read_text(
+                    encoding="utf-8"
+                )
+                self.assertIn(expectedSlackwareVersion, contents)
+
+        slintInfo = (
+            self.repository / "distro-packages" / "Slint" / "cthulhu-info"
+        ).read_text(encoding="utf-8")
+        self.assertRegex(
+            slintInfo,
+            rf'(?m)^VERSION="{re.escape(self.releaseVersion)}"$',
+        )
+
+    def test_stable_helper_has_release_contract(self) -> None:
+        contents = self.helperPkgbuilds[0].read_text(encoding="utf-8")
+        self.assertRegex(contents, r"(?m)^arch=\(x86_64\)$")
+        self.assertRegex(contents, r'(?m)^  "cthulhu=\$\{pkgver\}"$')
+
+    def test_optional_helper_packages_own_the_wine_dependency(self) -> None:
         for pkgbuild in self.helperPkgbuilds:
             with self.subTest(pkgbuild=pkgbuild):
                 contents = pkgbuild.read_text(encoding="utf-8")
                 self.assertIn("-Dwine-access=enabled", contents)
                 self.assertRegex(contents, r"(?m)^  wine$")
 
-    def test_optional_helper_packages_disable_lto(self):
+    def test_optional_helper_packages_disable_lto(self) -> None:
         for pkgbuild in self.helperPkgbuilds:
             with self.subTest(pkgbuild=pkgbuild):
                 contents = pkgbuild.read_text(encoding="utf-8")
                 self.assertRegex(contents, r"(?m)^options=\(!lto\)$")
 
-    def test_git_sources_declare_git_as_a_build_dependency(self):
+    def test_git_sources_declare_git_as_a_build_dependency(self) -> None:
         for pkgbuild in self.pkgbuilds + self.helperPkgbuilds:
             with self.subTest(pkgbuild=pkgbuild):
                 contents = pkgbuild.read_text(encoding="utf-8")