Cross-export Windows release package on Linux

docs/PROJECT-STRUCTURE.md

@@ -47,14 +47,17 @@ S:\Game Hacking\Eushully\Himegari\           ← workspace root (three siblings)
     │   ├── validate.py                        layered core/workspace/runtime/full validation driver
     │   ├── test_validate.py                   pure resolver + validation-plan regressions
     │   ├── build-linux-x64.sh                 one-command pinned Linux export/package/smoke pipeline
+    │   ├── build-windows-x64.sh               Linux-hosted Windows cross-export/package pipeline
     │   ├── dotnet_publish_proxy.py            guarded low-memory Godot export-time publish staging
     │   ├── publish_gitea_release.py           guarded/retry-safe native Gitea release promotion
     │   ├── verify_windows_native.py           static AMD64 PE/native-bundle contract verifier
     │   ├── bootstrap-godot-linux-x64.sh       repo-local Godot 4.7 Linux editor/template bootstrap
     │   ├── godot-linux-x64.json               immutable Godot editor/template source + SHA-256 manifest
     │   ├── install_godot_templates.py         selective HTTP-range installer for pinned template members
-    │   ├── package_linux_x64.py               export verifier + notice/checksum/archive packager
+    │   ├── package_linux_x64.py,
+    │   │   package_windows_x64.py             target-specific export verifiers and normalized packagers
     │   ├── test_install_godot_templates.py, test_package_linux_x64.py,
+    │   │   test_package_windows_x64.py,
     │   │   test_dotnet_publish_proxy.py,
     │   │   test_publish_gitea_release.py,
     │   │   test_verify_windows_native.py       source-only bootstrap/package/publish/native regressions
@@ -109,9 +112,10 @@ S:\Game Hacking\Eushully\Himegari\           ← workspace root (three siblings)
     ├── build/                               DERIVED (our-work-side) — generated by tools/; disposable
     │   ├── downloads/, toolchains/             immutable dependency caches and repo-local Godot toolchain
     │   ├── export/linux-x64/                   verified loose Godot Linux export
+    │   ├── export/windows-x64/                 structurally verified loose Godot Windows export
     │   ├── native/linux-x64/                   validated Linux FFmpeg shim/shared-library bundle
     │   ├── native/win-x64/                     validated Windows FFmpeg shim/DLL bundle
-    │   ├── package/                            staged release tree, smoke log, and `.tar.gz` artifact
+    │   ├── package/                            Linux staged tree/smoke/`.tar.gz` plus Windows x64 staged tree/ZIP
     │   ├── disasm/                            <NAME>.asm — human-readable disassembly, one per script
     │   ├── text/                              extracted text:
     │   │   ├── <NAME>.strings.txt               all inline strings in a script
@@ -160,9 +164,10 @@ S:\Game Hacking\Eushully\Himegari\           ← workspace root (three siblings)
 ```
 
 The Godot deliverable includes `Himegari.sln` because Godot's .NET exporter requires a solution,
-`export_presets.cfg` for the Linux x86_64 target, and `build/.gdignore` so disposable capture frames below
-the project do not enter its import or export scan. `tools/export-linux-x64.ps1` produces and validates the
-complete disposable artifact under `build/export/linux-x64/`.
+`export_presets.cfg` for Linux and Windows x86_64, and `build/.gdignore` so disposable capture frames below
+the project do not enter its import or export scan. `tools/build-linux-x64.sh` and
+`tools/build-windows-x64.sh` produce their complete disposable artifacts under `build/export/`; the older
+Windows-hosted `tools/export-linux-x64.ps1` remains a Linux-export development path.
 
 `godot/Main.cs` retains the front-end's startup and runtime coordination. Behavior-neutral partial-class
 companions keep cohesive surfaces independently navigable without changing the Godot node type or invocation

docs/platform-portability.md

@@ -84,7 +84,7 @@ lightweight `v0.1.0` tag at `5fe3cd6` on 2026-08-03: the tag build and promotion
 the Gitea release carries the archive, archive checksum, build metadata, payload ledger, and smoke log. The Linux
 CI/CD path is therefore accepted end to end.
 
-## Planned Windows x64 CI/CD artifact
+## Windows x64 CI/CD artifact
 
 The Windows artifact will be cross-built on the existing Linux runner; neither a Windows runner nor Wine is part
 of its build contract. The .NET SDK publishes `win-x64`, the Linux Godot editor exports through the pinned Windows
@@ -103,12 +103,26 @@ MinGW builds produced the identical shim SHA-256
 `9852680ca32bc37200d0b63ad89acb5453ad913bdcf4441a15c8ac9356d4da8c`. This is a compiler-independent contract
 comparison, not an expectation that MSVC and MinGW produce byte-identical binaries.
 
-The Windows build command will mirror the accepted Linux entry point while keeping target checks separate. It
-will regenerate opcode metadata, selectively install the Windows template from the existing pinned Godot TPZ,
-bootstrap/hash-check the pinned Windows FFmpeg SDK, cross-build and inspect `age_movie_ffmpeg.dll`, perform an
-exact self-contained `ExportRelease/win-x64` publish, and run the real Godot Windows export. The low-memory publish
-proxy will become target-parameterized rather than duplicating its fail-closed project/configuration/RID/output
-checks. The accepted Linux path must remain byte- and behavior-compatible throughout this extension.
+The cross-export/package contract was completed and locally accepted on 2026-08-03. The shared Godot manifest
+now pins both release-template members while each build range-fetches only its selected target; Windows adds the
+109,405,184-byte `windows_release_x86_64.exe` member with independently recorded SHA-256. The guarded publish
+proxy requires its driver-selected RID, so the same low-memory sequence produces exact self-contained
+`ExportRelease/linux-x64` and `ExportRelease/win-x64` payloads without weakening the project/configuration/RID/
+output-root checks. `tools/build-windows-x64.sh` composes the pinned editor/template, MinGW native bundle, .NET
+publish, real Godot export, static verifier, and normalized ZIP. Its verifier requires the executable/PCK,
+self-contained runtime, three project assemblies plus `Age.Engine.Text.Windows.dll`, native FFmpeg bundle and
+license; it rejects Linux shared objects and checks the Godot EXE plus all six native DLLs as AMD64 PE. The ZIP
+contains project notices, clean-source/dependency metadata, a complete payload checksum ledger, and the static
+verification report under one stable root. A WSL cross-build completed in 91.3 seconds and two package passes
+were byte-identical; the resulting packaged EXE also reported
+`PACKAGE SMOKE OK: opcodes=548 ffmpeg-abi=3` when optionally run on the Windows host. CI remains structural and
+will not execute that EXE.
+
+The Windows build command mirrors the accepted Linux entry point while keeping target checks separate. It
+regenerates opcode metadata, selectively installs the Windows template from the existing pinned Godot TPZ,
+bootstrap/hash-checks the pinned Windows FFmpeg SDK, cross-builds and inspects `age_movie_ffmpeg.dll`, performs an
+exact self-contained `ExportRelease/win-x64` publish, and runs the real Godot Windows export. The accepted Linux
+path retains its target selection and dynamic package-smoke behavior.
 
 CI acceptance is structural because the produced executable will not run on the Linux host. The verifier must
 require the Windows executable/PCK/self-contained managed directory, `Age.Engine.Text.Windows.dll`, the project

docs/remake-architecture-and-roadmap.md

@@ -1063,6 +1063,16 @@ do not mix mechanical moves with semantic changes.
    next step: Windows Godot template/export, target-parameterized publish proxy, structural package contract, and
    normalized ZIP.
 
+   **Slice 2 completed 2026-08-03:** the shared Godot manifest now pins and selectively fetches either release
+   template, the guarded low-memory publish proxy requires the calling driver's exact Linux or Windows RID, and
+   the Windows preset includes the conditional exact-GDI assembly. `tools/build-windows-x64.sh` performs the
+   complete metadata/native/publish/Godot/export/verify/package sequence without Wine. Its packager rejects
+   incomplete or Linux-contaminated payloads, verifies the Godot EXE and six native DLLs as AMD64 PE, embeds
+   notices/build provenance/payload checksums/static verification, and emits one normalized ZIP. Synthetic
+   template/proxy/package tests pass; the 91.3-second WSL cross-export passed, repeated packaging was byte-for-byte
+   stable, and an optional Windows-host run of the packaged EXE reported the 548-opcode/FFmpeg-ABI-3 smoke marker.
+   Slice 3 is now active: add the read-only hosted Windows artifact job while retaining the accepted Linux job.
+
    **Completion gate:** one deliberately selected future tag produces a single Gitea release containing the
    Linux `.tar.gz`, Windows `.zip`, and combined archive checksums; both archives bind to the tag commit, Linux
    retains its dynamic packaged smoke, Windows passes all structural PE/payload gates, and neither platform job

docs/tools-reference.md

@@ -429,6 +429,41 @@ The bootstrap prints the pinned editor path. The verifier prints the accepted ex
 prints the staged root and archive path. Those Python components and the guarded publish proxy have source-only
 synthetic regressions in the core validation level.
 
+**Windows x64 cross-export** uses the same pinned Linux editor and low-memory publish boundary, with MinGW and
+the selectively installed Windows template:
+
+```bash
+./tools/build-windows-x64.sh
+```
+
+The command requires Python 3.11, the `global.json` .NET SDK, MinGW-w64 GCC/binutils, `curl`, and `sha256sum`.
+It regenerates runtime metadata, builds and statically verifies the pinned Windows FFmpeg bundle, publishes the
+exact self-contained `ExportRelease/win-x64` managed runtime, and performs the real Godot `Windows x86_64`
+release export. No produced Windows program is executed. `package_windows_x64.py` requires the Godot AMD64 EXE,
+PCK, self-contained runtime, project assemblies including `Age.Engine.Text.Windows.dll`, and FFmpeg DLL/license
+set; it rejects Linux shared objects and embeds `BUILD-INFO.json`, `WINDOWS-VERIFICATION.json`, notices, and a
+complete `SHA256SUMS`. The normalized output is
+`build/package/windows-x64/OpenMaidEngine-Himegari-windows-x64.zip`.
+
+Focused commands are:
+
+```bash
+./tools/bootstrap-godot-linux-x64.sh windows-x64
+python3 -X utf8 tools/package_windows_x64.py verify build/export/windows-x64
+python3 -X utf8 tools/package_windows_x64.py package build/export/windows-x64
+```
+
+The bootstrap defaults to `linux-x64`; passing `windows-x64` changes only the selectively installed template.
+The package verifier needs `x86_64-w64-mingw32-objdump` unless `--objdump` names an equivalent tool. On a real
+Windows host, an extracted package can optionally run the same asset-independent dynamic gate as Linux:
+
+```powershell
+.\Himegari.exe --headless -- --package-smoke
+```
+
+That command proves the embedded 548-opcode table and local FFmpeg ABI 3 load. It is a manual acceptance aid,
+not part of Linux-hosted Windows CI.
+
 The older Windows-hosted cross-export remains available for local development:
 
 ```powershell