cabloy 5.1.215 → 5.1.217

package/.cabloy-version

@@ -1 +1 @@
-5.1.215
+5.1.217

package/.github/workflows/playwright-e2e.yml

@@ -5,15 +5,24 @@ on:
       - main
 jobs:
   basic-e2e:
-    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
     env:
       DATABASE_DEFAULT_CLIENT: sqlite3
       PNPM_CONFIG_MINIMUM_RELEASE_AGE: 0
     services:
       redis:
-        image: redis:latest
+        image: ${{ matrix.os == 'ubuntu-latest' && 'redis:latest' || '' }}
         ports:
           - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 5s
+          --health-timeout 3s
+          --health-retries 12
     steps:
       - uses: actions/checkout@v6
       - uses: actions/setup-node@v6
@@ -22,32 +31,106 @@ jobs:
       - uses: pnpm/action-setup@v5
         with:
           version: 11.5.2
+      - name: start Redis on macOS
+        if: runner.os == 'macOS'
+        shell: bash
+        run: |
+          brew install redis
+          redis_bin="$(brew --prefix redis)/bin"
+          redis_log="$RUNNER_TEMP/redis.log"
+          if ! "$redis_bin/redis-server" --bind 127.0.0.1 --port 6379 \
+            --daemonize yes --save '' --appendonly no --logfile "$redis_log"; then
+            if [[ -f "$redis_log" ]]; then
+              cat "$redis_log"
+            fi
+            exit 1
+          fi
+          for attempt in {1..30}; do
+            if response="$("$redis_bin/redis-cli" -h 127.0.0.1 -p 6379 ping 2>&1)" &&
+              [[ "$response" == PONG ]]; then
+              exit 0
+            fi
+            sleep 1
+          done
+          printf '::error::Redis readiness failed: %s\n' "$response"
+          if [[ -f "$redis_log" ]]; then
+            cat "$redis_log"
+          fi
+          exit 1
+      - name: start Redis on Windows
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          $ErrorActionPreference = 'Stop'
+          # Pinned third-party development build; retain its bundled Cygwin runtime.
+          $archive = Join-Path $env:RUNNER_TEMP 'redis-8.2.10.zip'
+          $directory = Join-Path $env:RUNNER_TEMP 'redis-8.2.10'
+          Invoke-WebRequest 'https://github.com/redis-windows/redis-windows/releases/download/8.2.10/Redis-8.2.10-Windows-x64-cygwin.zip' -OutFile $archive
+          $expected = '92d9bdde87ed52bf859a677e5197d8ac855ba78d9940d457881723ae960df429'
+          if ((Get-FileHash $archive -Algorithm SHA256).Hash.ToLowerInvariant() -ne $expected) {
+            throw 'Redis archive checksum mismatch'
+          }
+          Expand-Archive $archive -DestinationPath $directory
+          $servers = @(Get-ChildItem $directory -Recurse -Filter redis-server.exe)
+          if ($servers.Count -ne 1) { throw 'Expected one Redis server executable' }
+          $redisDirectory = $servers[0].DirectoryName
+          $cli = Join-Path $redisDirectory 'redis-cli.exe'
+          $config = Join-Path $redisDirectory 'ci.conf'
+          @('bind 127.0.0.1', 'port 6379', 'protected-mode yes', 'save ""', 'appendonly no', 'daemonize no', 'logfile redis.log') |
+            Set-Content $config -Encoding utf8NoBOM
+          $server = Start-Process $servers[0].FullName -ArgumentList 'ci.conf' -WorkingDirectory $redisDirectory -PassThru
+          for ($attempt = 0; $attempt -lt 30; $attempt++) {
+            $server.Refresh()
+            if ($server.HasExited) { break }
+            $response = & $cli -h 127.0.0.1 -p 6379 ping 2>&1
+            if ($LASTEXITCODE -eq 0 -and "$response".Trim() -eq 'PONG') { exit 0 }
+            Start-Sleep -Seconds 1
+          }
+          $log = Join-Path $redisDirectory 'redis.log'
+          if (Test-Path $log) { Get-Content $log }
+          throw 'Redis did not become ready'
       - name: init
         run: npm run init
-      - name: install Chromium
+      - name: install Chromium with Linux dependencies
+        if: runner.os == 'Linux'
         run: npx playwright install --with-deps chromium
+      - name: install Chromium on Windows and macOS
+        if: runner.os != 'Linux'
+        run: npx playwright install chromium
+      - name: run focused managed E2E regression gate
+        run: node --test zova/packages-utils/zova-vite/test/configUtils.test.ts scripts/testClaimProcesses.test.ts scripts/runIsolatedTest.test.ts scripts/generateOpenapiIsolated.test.ts scripts/testClaimCleanup.test.ts scripts/testProcessGuardianWindows.test.ts scripts/testBrowserGuardianWindows.test.ts vona/packages-vona/vona-core/src/lib/core/testClaim.test.ts vona/packages-vona/vona-core/src/lib/core/testClaimFilesystem.test.ts vona/packages-vona/vona-core/src/lib/framework/processWorker.test.ts vona/src/suite-vendor/a-vona/modules/a-static/test/middlewareSystem.static.test.ts vona/src/suite-vendor/a-vona/modules/a-metrics/test/middlewareSystem.health.test.ts vona/src/suite-vendor/a-vona/modules/a-logger/test/middlewareSystem.httpLog.test.ts vona/src/suite-vendor/a-vona/modules/a-logger/src/lib/redactIsolatedReadyHeader.test.ts repo-e2e/scripts/managedTest.test.ts repo-e2e/scripts/managedTestImports.test.ts repo-e2e/scripts/e2e.test.ts repo-e2e/scripts/runE2eArgs.test.ts repo-e2e/scripts/runE2e.test.ts
       - name: run Basic E2E baseline
         run: npm run test:e2e -- cabloy-basic home-user-account
       - name: upload Playwright artifacts
         if: failure()
         uses: actions/upload-artifact@v7
         with:
-          name: playwright-artifacts-basic
+          name: playwright-artifacts-basic-${{ matrix.os }}
           path: |
-            playwright-report/
-            test-results/
+            vona/.app-test-*/playwright-report/
+            vona/.app-test-*/test-results/
+          include-hidden-files: true
           if-no-files-found: ignore
 
   commerce-e2e:
-    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
     env:
       DATABASE_DEFAULT_CLIENT: sqlite3
       PNPM_CONFIG_MINIMUM_RELEASE_AGE: 0
     services:
       redis:
-        image: redis:latest
+        image: ${{ matrix.os == 'ubuntu-latest' && 'redis:latest' || '' }}
         ports:
           - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 5s
+          --health-timeout 3s
+          --health-retries 12
     steps:
       - uses: actions/checkout@v6
       - uses: actions/setup-node@v6
@@ -56,22 +139,89 @@ jobs:
       - uses: pnpm/action-setup@v5
         with:
           version: 11.5.2
+      - name: start Redis on macOS
+        if: runner.os == 'macOS'
+        shell: bash
+        run: |
+          brew install redis
+          redis_bin="$(brew --prefix redis)/bin"
+          redis_log="$RUNNER_TEMP/redis.log"
+          if ! "$redis_bin/redis-server" --bind 127.0.0.1 --port 6379 \
+            --daemonize yes --save '' --appendonly no --logfile "$redis_log"; then
+            if [[ -f "$redis_log" ]]; then
+              cat "$redis_log"
+            fi
+            exit 1
+          fi
+          for attempt in {1..30}; do
+            if response="$("$redis_bin/redis-cli" -h 127.0.0.1 -p 6379 ping 2>&1)" &&
+              [[ "$response" == PONG ]]; then
+              exit 0
+            fi
+            sleep 1
+          done
+          printf '::error::Redis readiness failed: %s\n' "$response"
+          if [[ -f "$redis_log" ]]; then
+            cat "$redis_log"
+          fi
+          exit 1
+      - name: start Redis on Windows
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          $ErrorActionPreference = 'Stop'
+          # Pinned third-party development build; retain its bundled Cygwin runtime.
+          $archive = Join-Path $env:RUNNER_TEMP 'redis-8.2.10.zip'
+          $directory = Join-Path $env:RUNNER_TEMP 'redis-8.2.10'
+          Invoke-WebRequest 'https://github.com/redis-windows/redis-windows/releases/download/8.2.10/Redis-8.2.10-Windows-x64-cygwin.zip' -OutFile $archive
+          $expected = '92d9bdde87ed52bf859a677e5197d8ac855ba78d9940d457881723ae960df429'
+          if ((Get-FileHash $archive -Algorithm SHA256).Hash.ToLowerInvariant() -ne $expected) {
+            throw 'Redis archive checksum mismatch'
+          }
+          Expand-Archive $archive -DestinationPath $directory
+          $servers = @(Get-ChildItem $directory -Recurse -Filter redis-server.exe)
+          if ($servers.Count -ne 1) { throw 'Expected one Redis server executable' }
+          $redisDirectory = $servers[0].DirectoryName
+          $cli = Join-Path $redisDirectory 'redis-cli.exe'
+          $config = Join-Path $redisDirectory 'ci.conf'
+          @('bind 127.0.0.1', 'port 6379', 'protected-mode yes', 'save ""', 'appendonly no', 'daemonize no', 'logfile redis.log') |
+            Set-Content $config -Encoding utf8NoBOM
+          $server = Start-Process $servers[0].FullName -ArgumentList 'ci.conf' -WorkingDirectory $redisDirectory -PassThru
+          for ($attempt = 0; $attempt -lt 30; $attempt++) {
+            $server.Refresh()
+            if ($server.HasExited) { break }
+            $response = & $cli -h 127.0.0.1 -p 6379 ping 2>&1
+            if ($LASTEXITCODE -eq 0 -and "$response".Trim() -eq 'PONG') { exit 0 }
+            Start-Sleep -Seconds 1
+          }
+          $log = Join-Path $redisDirectory 'redis.log'
+          if (Test-Path $log) { Get-Content $log }
+          throw 'Redis did not become ready'
       - name: init
         run: npm run init
-      - name: install Chromium
+      - name: install Chromium with Linux dependencies
+        if: runner.os == 'Linux'
         run: npx playwright install --with-deps chromium
+      - name: install Chromium on Windows and macOS
+        if: runner.os != 'Linux'
+        run: npx playwright install chromium
+      - name: run focused managed E2E regression gate
+        run: node --test zova/packages-utils/zova-vite/test/configUtils.test.ts scripts/testClaimProcesses.test.ts scripts/runIsolatedTest.test.ts scripts/generateOpenapiIsolated.test.ts scripts/testClaimCleanup.test.ts scripts/testProcessGuardianWindows.test.ts scripts/testBrowserGuardianWindows.test.ts vona/packages-vona/vona-core/src/lib/core/testClaim.test.ts vona/packages-vona/vona-core/src/lib/core/testClaimFilesystem.test.ts vona/packages-vona/vona-core/src/lib/framework/processWorker.test.ts vona/src/suite-vendor/a-vona/modules/a-static/test/middlewareSystem.static.test.ts vona/src/suite-vendor/a-vona/modules/a-metrics/test/middlewareSystem.health.test.ts vona/src/suite-vendor/a-vona/modules/a-logger/test/middlewareSystem.httpLog.test.ts vona/src/suite-vendor/a-vona/modules/a-logger/src/lib/redactIsolatedReadyHeader.test.ts repo-e2e/scripts/managedTest.test.ts repo-e2e/scripts/managedTestImports.test.ts repo-e2e/scripts/e2e.test.ts repo-e2e/scripts/runE2eArgs.test.ts repo-e2e/scripts/runE2e.test.ts
+      - name: run Commerce cart model regression
+        run: node --test zova/src/suite/a-commerce/modules/commerce-trade/test/lib/cartModel.test.ts
       - name: build Commerce Zova artifacts
         run: npm run build:zova:commerce
       - name: synchronize Vona dependencies
         run: npm run deps:vona
       - name: run Commerce E2E baseline
-        run: npm run test:e2e a-commerce markdown
+        run: npm run test:e2e -- a-commerce markdown
       - name: upload Playwright artifacts
         if: failure()
         uses: actions/upload-artifact@v7
         with:
-          name: playwright-artifacts-commerce
+          name: playwright-artifacts-commerce-${{ matrix.os }}
           path: |
-            playwright-report/
-            test-results/
+            vona/.app-test-*/playwright-report/
+            vona/.app-test-*/test-results/
+          include-hidden-files: true
           if-no-files-found: ignore

package/.github/workflows/vona-test-sqlite3.yml

@@ -8,15 +8,22 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
         node-version: [24]
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     env:
       PNPM_CONFIG_MINIMUM_RELEASE_AGE: 0
+      DATABASE_DEFAULT_CLIENT: sqlite3
     services:
       redis:
-        image: redis:latest
+        image: ${{ matrix.os == 'ubuntu-latest' && 'redis:latest' || '' }}
         ports:
           - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 5s
+          --health-timeout 3s
+          --health-retries 12
     steps:
       - uses: actions/checkout@v6
       - uses: actions/setup-node@v6
@@ -25,19 +32,82 @@ jobs:
       - uses: pnpm/action-setup@v5
         with:
           version: 11.5.2
+      - name: start Redis on macOS
+        if: runner.os == 'macOS'
+        shell: bash
+        run: |
+          brew install redis
+          redis_bin="$(brew --prefix redis)/bin"
+          redis_log="$RUNNER_TEMP/redis.log"
+          if ! "$redis_bin/redis-server" --bind 127.0.0.1 --port 6379 \
+            --daemonize yes --save '' --appendonly no --logfile "$redis_log"; then
+            if [[ -f "$redis_log" ]]; then
+              cat "$redis_log"
+            fi
+            exit 1
+          fi
+          for attempt in {1..30}; do
+            if response="$("$redis_bin/redis-cli" -h 127.0.0.1 -p 6379 ping 2>&1)" &&
+              [[ "$response" == PONG ]]; then
+              exit 0
+            fi
+            sleep 1
+          done
+          printf '::error::Redis readiness failed: %s\n' "$response"
+          if [[ -f "$redis_log" ]]; then
+            cat "$redis_log"
+          fi
+          exit 1
+      - name: start Redis on Windows
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          $ErrorActionPreference = 'Stop'
+          # Pinned third-party development build; retain its bundled Cygwin runtime.
+          $archive = Join-Path $env:RUNNER_TEMP 'redis-8.2.10.zip'
+          $directory = Join-Path $env:RUNNER_TEMP 'redis-8.2.10'
+          Invoke-WebRequest 'https://github.com/redis-windows/redis-windows/releases/download/8.2.10/Redis-8.2.10-Windows-x64-cygwin.zip' -OutFile $archive
+          $expected = '92d9bdde87ed52bf859a677e5197d8ac855ba78d9940d457881723ae960df429'
+          if ((Get-FileHash $archive -Algorithm SHA256).Hash.ToLowerInvariant() -ne $expected) {
+            throw 'Redis archive checksum mismatch'
+          }
+          Expand-Archive $archive -DestinationPath $directory
+          $servers = @(Get-ChildItem $directory -Recurse -Filter redis-server.exe)
+          if ($servers.Count -ne 1) { throw 'Expected one Redis server executable' }
+          $redisDirectory = $servers[0].DirectoryName
+          $cli = Join-Path $redisDirectory 'redis-cli.exe'
+          $config = Join-Path $redisDirectory 'ci.conf'
+          @('bind 127.0.0.1', 'port 6379', 'protected-mode yes', 'save ""', 'appendonly no', 'daemonize no', 'logfile redis.log') |
+            Set-Content $config -Encoding utf8NoBOM
+          $server = Start-Process $servers[0].FullName -ArgumentList 'ci.conf' -WorkingDirectory $redisDirectory -PassThru
+          for ($attempt = 0; $attempt -lt 30; $attempt++) {
+            $server.Refresh()
+            if ($server.HasExited) { break }
+            $response = & $cli -h 127.0.0.1 -p 6379 ping 2>&1
+            if ($LASTEXITCODE -eq 0 -and "$response".Trim() -eq 'PONG') { exit 0 }
+            Start-Sleep -Seconds 1
+          }
+          $log = Join-Path $redisDirectory 'redis.log'
+          if (Test-Path $log) { Get-Content $log }
+          throw 'Redis did not become ready'
       - name: init
         run: npm run init
+      - name: run isolated test infrastructure gate
+        run: node --test scripts/testClaimProcesses.test.ts scripts/runIsolatedTest.test.ts scripts/testClaimCleanup.test.ts scripts/testProcessGuardianWindows.test.ts vona/packages-vona/vona-core/src/lib/core/testClaim.test.ts vona/packages-vona/vona-core/src/lib/core/testClaimFilesystem.test.ts vona/packages-vona/vona-core/src/lib/framework/bootstrap.test.ts vona/packages-vona/vona-core/src/lib/framework/useApp.test.ts vona/packages-cli/cli-set-api/test/binBuildEntries.test.ts
       - name: run A-Pay focused gate
-        run: DATABASE_DEFAULT_CLIENT=sqlite3 npm run vona :bin:test -- test-pay/test/paymentSession.test.ts test-pay/test/payMock.test.ts test-pay/test/paypalProvider.test.ts test-pay/test/paypalLifecycle.test.ts test-pay/test/stripeProvider.test.ts test-pay/test/stripeLifecycle.test.ts test-pay/test/outbox.test.ts test-pay/test/webhook.test.ts --flavor=normal
+        run: npm run test -- test-pay/test/paymentSession.test.ts test-pay/test/payMock.test.ts test-pay/test/paypalProvider.test.ts test-pay/test/paypalLifecycle.test.ts test-pay/test/stripeProvider.test.ts test-pay/test/stripeLifecycle.test.ts test-pay/test/outbox.test.ts test-pay/test/webhook.test.ts
         working-directory: vona
       - name: run Commerce payment, shipment, and refund lifecycle gate
-        run: DATABASE_DEFAULT_CLIENT=sqlite3 npm run vona :bin:test -- commerce-trade/test/paymentOutcome.test.ts commerce-trade/test/reservationExpiry.test.ts commerce-trade/test/shipment.test.ts commerce-trade/test/refundLifecycle.test.ts --flavor=normal
+        run: npm run test -- commerce-trade/test/paymentOutcome.test.ts commerce-trade/test/reservationExpiry.test.ts commerce-trade/test/shipment.test.ts commerce-trade/test/refundLifecycle.test.ts
         working-directory: vona
-      - run: DATABASE_DEFAULT_CLIENT=sqlite3 npm run test
+      - run: npm run test
         working-directory: vona
-      - run: DATABASE_DEFAULT_CLIENT=sqlite3 npm run build -- --flavor=ci
+      - run: npm run build -- --flavor=ci
         working-directory: vona
+        env:
+          # The full backend bundle exceeds the macOS runner's default 2 GiB V8 heap.
+          NODE_OPTIONS: --max-old-space-size=4096
       - run: pnpm -C ./dist/ci install
         working-directory: vona
-      - run: DATABASE_DEFAULT_CLIENT=sqlite3 npm run play -- --mode=prod --flavor=ci
+      - run: npm run play -- --mode=prod --flavor=ci
         working-directory: vona

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 5.1.217
+
+### Features
+
+- Add end-to-end testing on Windows.
+
+### Improvements
+
+- Improve Windows support and end-to-end test coverage.
+- Update the SQLite test workflow.
+- Update claim tests.
+
+## 5.1.216
+
+### Features
+
+- Apply feature updates.
+
+### Improvements
+
+- Update the agent governance configuration.
+
 ## 5.1.215
 
 ### Features

package/CONTRIBUTING.md

@@ -21,7 +21,7 @@ npm run init
 
 `npm run init` is more than a package install: it installs multiple workspaces, prepares generated local configuration, initializes and synchronizes Vona and Zova, and generates required frontend and backend artifacts. Run it intentionally rather than as a retry for an unrelated narrow change.
 
-Current CI workflows run on Ubuntu with Node.js 24 after pushes to `main`; do not assume that every pull request is automatically validated. For maintained edition and onboarding guidance, see [Cabloy Editions](https://cabloy.com/editions/overview#cabloy-basic).
+CI workflows run after pushes to `main`; do not assume that every pull request is automatically validated. The SQLite unit-test and Chromium Basic/Commerce E2E workflows configure Ubuntu, Windows, and macOS with Node.js 24 and pnpm 11.5.2. Matrix configuration alone is not proof that the platform gates or all six Basic/Commerce E2E combinations passed. For maintained edition and onboarding guidance, see [Cabloy Editions](https://cabloy.com/editions/overview#cabloy-basic).
 
 ## Develop and validate
 
@@ -44,7 +44,9 @@ Start with the narrowest meaningful check, then broaden validation when a change
 | Synchronize Zova dependencies into Vona   | `npm run deps:vona`        |
 | Build the public documentation site       | `npm run docs:build`       |
 
-`npm run test:e2e` starts a fresh runner-managed local Vona worker in test mode and runs Playwright against Vona integrated SSR. Select flat spec basenames directly after the script, for example `npm run test:e2e a-commerce`; place Playwright filters after npm's `--` delimiter, for example `npm run test:e2e a-commerce -- --tag @smoke`. Browser commands consume existing SSR/REST artifacts and do not rebuild them. Confirm exclusive ownership of the effective test database, local Redis namespace, public/runtime paths, application identity, API origin, and listener before starting a test-mode runtime; an available port alone is not sufficient. Externally managed `E2E_BASE_URL` targets are unsupported.
+`npm run test:e2e` starts a fresh runner-managed local Vona worker in test mode and runs Playwright against Vona integrated SSR. Select flat spec basenames directly after the script, for example `npm run test:e2e a-commerce`; place Playwright filters after npm's `--` delimiter, for example `npm run test:e2e a-commerce -- --tag @smoke`. Browser commands consume existing SSR/REST artifacts and do not rebuild them. The managed runner allocates run-owned database and Redis namespaces, runtime/public paths, application identity, API origin, and listener, so ordinary same-checkout development services are not a blocker by themselves. Coordinate shared build/dependency writes and check custom external resources separately; a free port alone is not ownership proof. Externally managed `E2E_BASE_URL` targets are unsupported.
+
+For native Windows managed tests, use the same public npm commands from CMD or PowerShell. PowerShell 7 on `PATH`, local NTFS storage, and reachable Redis are required; E2E additionally needs installed Chromium (`npx playwright install chromium`) and ready SSR/REST artifacts. Windows workers and browsers must prove membership in their designated registered Job, and normal Vona teardown uses authenticated cooperative shutdown before whole-Job drainage is accepted. POSIX browsers retain independent process-group verification. Failed or interrupted runs retain claims and resources for inspection; force-stop or missing PIDs do not establish successful cleanup. See [Native Windows managed tests](https://cabloy.com/reference/repo-scripts#native-windows-managed-tests) for the lifecycle and limits: the browser scope is Cabloy Basic Chromium Basic/Commerce baselines, not all browsers, documentation E2E, or Cabloy Start.
 
 The tracked pre-commit hook runs `lint-staged`. It may format staged Markdown and configuration files, and may lint-fix and format staged source files. Review the resulting staged changes and run the relevant explicit checks before submitting.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cabloy",
-  "version": "5.1.215",
+  "version": "5.1.217",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A Node.js fullstack framework",
   "keywords": [

package/repo-docs/frontend/scripts.md

@@ -79,6 +79,8 @@ npm run test:e2e a-commerce -- --tag @web --tag @smoke
 
 For the complete Basic tag vocabulary and managed-runner argument boundaries, see [Repo Scripts](/reference/repo-scripts#ssr-browser-checks). `E2E_BASE_URL` must be unset: externally managed targets are unsupported.
 
+Cabloy Basic's Chromium Basic/Commerce CI baselines configure Ubuntu, Windows, and macOS; a matrix declaration is not evidence that all six combinations passed. On native Windows, public commands work from CMD or PowerShell and require PowerShell 7 on `PATH`, local NTFS storage, reachable Redis, installed Chromium, and ready paired SSR/REST artifacts. Managed browsers inherit a registered non-breakaway Windows Job; both worker and browser membership are verified through its owning helper, and cleanup requires whole-Job drainage rather than browser close alone. Normal Windows server teardown uses authenticated cooperative shutdown; failures or interruption retain claims and resources. POSIX browsers retain independent process-group verification. See [Native Windows managed tests](/reference/repo-scripts#native-windows-managed-tests) for the prerequisites, lifecycle, and coverage limits; this is not a claim about Cabloy Start's Windows browser support.
+
 ## Cabloy Start root wrappers
 
 Cabloy Start is the public MIT-licensed edition. Its default root wrappers use the `cabloyStartAdmin` and `cabloyStartWeb` flavors:

package/repo-docs/reference/repo-scripts.md

@@ -60,7 +60,7 @@ Root `npm run test` delegates to Vona's `npm run test`; both it and direct `cd v
 
 Claims contain a versioned, nonsecret resource inventory: owned local roots, exact database allocation intents, Redis namespaces and endpoint identities, process ownership, and cleanup progress. Allocators must receive an acknowledgment that their intent is recorded before creating a database or using framework-managed Redis resources. Credentials, full environment/configuration snapshots, and readiness secrets are not stored in claims.
 
-Successful unit, coverage, and managed application E2E runs release inventoried database and Redis resources and remove their owned local roots after process shutdown is verified. Managed E2E uses a registered browser fixture to verify detached browser-group shutdown; its run-owned reports, traces, and temporary profiles are deleted on success too. The claim is deleted last. Failed or interrupted runs retain their claim and resources for inspection. Cleanup failure also makes the command fail and retains the journal for retry.
+Successful unit, coverage, and managed application E2E runs release inventoried database and Redis resources and remove their owned local roots after process shutdown is verified. Managed E2E uses a registered browser fixture: POSIX browsers have independently verified process groups, while Windows workers and browsers must prove membership in the designated registered guardian Job. Cleanup requires verified process-group or whole-Job drainage, respectively; browser close or a missing PID is not sufficient proof. Run-owned reports, traces, and temporary profiles are deleted on success too. The claim is deleted last. Failed or interrupted runs retain their claim and resources for inspection. Cleanup failure also makes the command fail and retains the journal for retry.
 
 Before each new invocation, the runner checks retained claims against their immutable UTC creation timestamp. Claims older than one day are eligible for cleanup; set `VONA_TEST_CLAIM_TTL_SECONDS` to a positive integer to change the default `86400` seconds. Eligibility is not permission to delete a live or unowned resource: the runner retains malformed claims, mismatched owner markers, symlinked paths, changed service endpoints, live or uncertain process identities, incomplete launch registrations, and claims with an existing cleanup lock. Inspect these warnings manually; a lock is never taken over merely because it is old. Cleanup resolves current trusted configuration without starting the application, running seeds, or opening a listener. It drops only recorded database names and scans only exact recorded Redis prefixes, never flushing Redis. Partial progress is journaled so a later eligible cleanup can retry safely. Legacy `.vona-test-claim-<id>` directories and inventory-less run roots are not automatically migrated or deleted.
 
@@ -86,6 +86,32 @@ For Vona integrated SSR, the allocated E2E origin is supplied to Zova at runtime
 
 For deliberate **dev-mode** database preparation, `npm run db:reset` is a separate, destructive command: in a single process, it clears validated application-owned Redis keys, drops and recreates managed disposable development databases, reruns migrations and instance initialization, then runs module `seed()` hooks. It requires `database.testDatabase: true` in the dev configuration and a connection outside the disposable database. Ordinary `npm run dev` and `npm run dev:one` only reuse existing managed databases; if any required target is missing, startup fails promptly with an instruction to run `npm run db:reset`. They do not create databases, perform creation-time Redis cleanup, or seed. Never run `db:reset` against development data you need to retain. Upgrades do not reset existing development data or repeat its seeds. See [Development database preparation](#development-database-preparation) and [Migration and Changes](/backend/migration-and-changes#local-development-workflow).
 
+### Native Windows managed tests {#native-windows-managed-tests}
+
+<span id="native-windows-unit-tests"></span>
+
+The Cabloy Basic SQLite unit-test workflow and Chromium application E2E workflow configure native Windows runners alongside Ubuntu and macOS. Each E2E suite has its own three-OS matrix with `fail-fast: false`, Node.js 24, pnpm 11.5.2, and SQLite. Basic selects `cabloy-basic home-user-account`; Commerce selects `a-commerce markdown` and retains its explicit Commerce artifact build and Vona dependency synchronization. A configured matrix is not proof of a successful run: inspect the focused gates, real Windows Chromium lifecycle regressions, and all six hosted Basic/Commerce suite-and-OS results before claiming verified platform compatibility.
+
+On Windows, the managed test entrypoints require Node.js with npm, PowerShell 7 (`pwsh.exe` on `PATH`), local NTFS storage, and a reachable Redis service. E2E also requires Playwright's Chromium installation and current SSR/REST artifacts with Vona dependencies synchronized. PowerShell is an internal helper dependency, not a required interactive terminal. From either CMD or PowerShell, use the same public commands:
+
+```text
+npm run test
+npx playwright install chromium
+npm run test:e2e -- cabloy-basic home-user-account
+```
+
+The Node runner explicitly invokes its checked-in Windows helper; it does not interpret PowerShell code in the caller's shell or download a helper runtime. It uses a non-breakaway Windows Job Object to contain the test process tree, with job membership established at process creation and kill-on-close ownership. Claim directories and files use protected private Windows ACLs and reject unsafe reparse points and hardlinks. Flushed file contents and same-volume atomic updates provide the supported local-NTFS process-crash publication contract; this is not a claim of POSIX directory-fsync equivalence or power-loss durability.
+
+A missing native capability, unsafe claim storage, ambiguous process identity, or unproven job drainage fails closed. Failed/interrupted runs retain their claims; helper disappearance alone never authorizes cleanup. Do not bypass these checks with raw test commands or remove retained resources without verifying ownership. The npm CLI is resolved from the npm invocation or its standard location beside the Node installation; a pnpm executable is not substituted for npm's JavaScript entrypoint.
+
+The Windows CI Redis setup uses a pinned, checksum-verified [third-party Redis Windows development distribution](https://github.com/redis-windows/redis-windows/releases/tag/8.2.10) with its bundled Cygwin runtime, bound to loopback. This is not an official Redis Windows port or a production deployment recommendation. Linux CI uses a Redis container with a health check; macOS starts native loopback Redis with bounded readiness polling. The native setups do not install persistent services. Local users must provision Redis deliberately; neither managed test command installs it. Chromium's `--with-deps` installation is Linux-only in CI; Windows and macOS use `playwright install chromium`.
+
+For Windows E2E, the managed fixture verifies the Playwright worker's membership before browser launch, then verifies the actual browser child's membership before connecting. The claim broker authenticates the query and asks the live helper owning that registered Job to check exact PID/creation-time identity and membership in that specific Job. An inherited registration locator, an environment flag, or membership in some other Job is not ownership proof. The Job handle stays private, and Windows browsers do not fabricate POSIX process-group claims. Inherited or custom `TEMP`, `TMP`, and `TMPDIR` names are handled case-insensitively and normalized to the run-owned temporary root.
+
+After authenticated readiness, normal Windows Vona teardown uses an authenticated, nonce-bound loopback shutdown request and acknowledgment, then awaits a zero server exit and the helper's whole-Job drainage proof. This path reuses the worker's awaited application-close lifecycle; it does not emulate POSIX graceful signals. Refusal, invalid proof, timeout, interruption, unexpected exit, or uncertain drainage fails the run and invokes failure-stop where possible. Force-stop is never reclassified as successful teardown. Controller/helper death and cancellation retain claims and resources; disappearing PIDs alone never authorize cleanup.
+
+The supported application browser scope here is Cabloy Basic's Chromium Basic/Commerce baselines, not every browser, documentation E2E, Cabloy Start, or generic POSIX signal parity. The E2E workflow uploads failure-only reports from `vona/.app-test-*/playwright-report/` and `vona/.app-test-*/test-results/`, including hidden run directories, under suite-and-OS-specific artifact names. It never uploads whole run roots. Failed runs retain local claims/resources for inspection, while successful runs remove their run-owned reports and profiles along with other inventoried resources.
+
 ## Specification planning and derived charts
 
 The current Cabloy Basic root scripts also expose:

package/repo-e2e/scripts/e2e.test.ts

@@ -17,7 +17,7 @@ test('rejects a defined E2E_BASE_URL before loading local configuration', () =>
 });
 
 test('isolated E2E target follows the assigned listener', () => {
-  const entrypoint = fileURLToPath(new URL('./e2e.ts', import.meta.url));
+  const entrypoint = new URL('./e2e.ts', import.meta.url).href;
   const result = spawnSync(
     process.execPath,
     [

package/repo-e2e/scripts/managedTest.test.ts

@@ -21,6 +21,7 @@ async function fixture(
     group?: number;
     noProfile?: boolean;
     exited?: boolean;
+    platform?: NodeJS.Platform;
   } = {},
 ) {
   const root = await realpath(await mkdtemp(join(tmpdir(), 'cabloy-managed-browser-')));
@@ -72,7 +73,9 @@ async function fixture(
       VONA_TEST_CLAIM_URL: 'http://127.0.0.1:1234/event',
       VONA_TEST_CLAIM_TOKEN: 'a'.repeat(64),
       TMPDIR: temporaryRoot,
+      ...(options.platform === 'win32' ? { TEMP: temporaryRoot, TMP: temporaryRoot } : {}),
     },
+    platform: options.platform ?? 'linux',
     projectPath,
     sendEvent: async (_env: NodeJS.ProcessEnv, event: TestClaimEvent) => {
       const stage = event.type === 'process' ? event.process.stage : event.type;
@@ -85,13 +88,24 @@ async function fixture(
       if (options.fault === 'inspect') throw new Error('inspection failed');
       return {
         pid,
-        pgid: options.group ?? pid,
-        startTime: 'Wed Oct 14 01:02:03 2026',
+        ...(options.platform === 'win32' ? {} : { pgid: options.group ?? pid }),
+        startTime: options.platform === 'win32' ? '134000000000000000' : 'Wed Oct 14 01:02:03 2026',
         host: 'test-host',
         state: 'S',
         args: '',
       };
     },
+    assertWindowsJob: async (
+      _env: NodeJS.ProcessEnv,
+      identity: { pid: number; startTime: string; host: string },
+    ) => {
+      const role = identity.pid === process.pid ? 'worker' : 'browser';
+      calls.push(`job-${role}`);
+      assert.equal(identity.startTime, '134000000000000000');
+      assert.equal(identity.host, 'test-host');
+      assert.equal(Object.hasOwn(identity, 'pgid'), false);
+      if (options.fault === `job-${role}`) throw new Error('designated Job membership unavailable');
+    },
     waitForGroupExit: async (pgid: number) => {
       calls.push('wait');
       assert.equal(pgid, 4242);
@@ -277,7 +291,7 @@ for (const invalid of ['tmpdir', 'owner', 'transport', 'connect', 'symlink']) {
       if (invalid === 'transport') f.dependencies.env.VONA_TEST_CLAIM_TOKEN = '';
       if (invalid === 'symlink') {
         await rm(f.temporaryRoot, { recursive: true });
-        await symlink(f.root, f.temporaryRoot);
+        await symlink(f.root, f.temporaryRoot, process.platform === 'win32' ? 'junction' : 'dir');
       }
       const options =
         invalid === 'connect'
@@ -364,6 +378,104 @@ test('rejects an explicit external profile argument before launch', async () =>
   }
 });
 
+test('Windows proves worker and browser Job membership without per-browser POSIX claims', async () => {
+  const f = await fixture({ platform: 'win32' });
+  try {
+    await useManagedBrowser(
+      f.browserOptions,
+      async () => {
+        f.calls.push('use');
+      },
+      f.dependencies,
+    );
+    assert.deepEqual(f.calls, [
+      'inspect',
+      'job-worker',
+      'launch',
+      'inspect',
+      'job-browser',
+      'connect',
+      'use',
+      'close',
+    ]);
+    assert.deepEqual(f.events, []);
+  } finally {
+    await f.dispose();
+  }
+});
+
+for (const fault of ['job-worker', 'job-browser', 'launch', 'inspect', 'connect', 'close']) {
+  test(`Windows fails closed on ${fault} without acknowledging browser drainage`, async () => {
+    const f = await fixture({ platform: 'win32', fault });
+    try {
+      await assert.rejects(useManagedBrowser(f.browserOptions, async () => {}, f.dependencies));
+      assert.deepEqual(f.events, []);
+      assert.ok(!f.calls.includes('wait'));
+      if (['job-worker', 'inspect'].includes(fault)) assert.ok(!f.calls.includes('launch'));
+      if (fault === 'job-browser') {
+        assert.ok(f.calls.includes('close'));
+        assert.ok(!f.calls.includes('connect'));
+      }
+    } finally {
+      await f.dispose();
+    }
+  });
+}
+
+for (const variable of ['TEMP', 'TMP', 'TMPDIR', 'temp']) {
+  test(`Windows rejects inherited ${variable} outside its run before browser launch`, async () => {
+    const f = await fixture({ platform: 'win32' });
+    try {
+      const env: NodeJS.ProcessEnv = { ...f.dependencies.env, [variable]: '/unowned' };
+      await assert.rejects(
+        useManagedBrowser(f.browserOptions, async () => {}, { ...f.dependencies, env }),
+        /run-owned temporary paths/,
+      );
+      assert.deepEqual(f.calls, []);
+    } finally {
+      await f.dispose();
+    }
+  });
+}
+
+test('Windows normalizes custom temporary environment names without mutating caller options', async () => {
+  const f = await fixture({ platform: 'win32' });
+  const env = { temp: '/unowned', Tmp: '/unowned', tmpdir: '/unowned', CUSTOM: 'keep' };
+  try {
+    await useManagedBrowser(
+      { ...f.browserOptions, launchOptions: { env } },
+      async () => {},
+      f.dependencies,
+    );
+    assert.deepEqual(f.launchedOptions()?.env, {
+      TEMP: f.temporaryRoot,
+      TMP: f.temporaryRoot,
+      TMPDIR: f.temporaryRoot,
+      CUSTOM: 'keep',
+    });
+    assert.equal(env.temp, '/unowned');
+    assert.equal(env.Tmp, '/unowned');
+    assert.equal(env.tmpdir, '/unowned');
+  } finally {
+    await f.dispose();
+  }
+});
+
+test('Windows closes a browser with an escaping actual profile without connecting', async () => {
+  const f = await fixture({ platform: 'win32', profile: '/unowned/profile' });
+  try {
+    await assert.rejects(
+      useManagedBrowser(f.browserOptions, async () => {}, f.dependencies),
+      /outside its run-owned area/,
+    );
+    assert.deepEqual(f.events, []);
+    assert.ok(f.calls.includes('close'));
+    assert.ok(!f.calls.includes('connect'));
+  } finally {
+    await f.dispose();
+  }
+});
+
 test('discovers exact Chromium and Firefox argv profiles; uses the temporary area for WebKit', () => {
   assert.equal(
     discoverBrowserProfile(['browser', '--user-data-dir=/run/tmp/with spaces']),