Merge remote-tracking branch 'origin/main' into codex/1154-main-refresh

.gitattributes

@@ -1,2 +1,10 @@
+# Font-build test fixtures are compared byte for byte: a checkout must not convert them.
+crates/fonts-build/tests/fixture/** -text
+
+# The pinned font index is hashed and compiled in as committed: a checkout must not convert its
+# line endings, or `Index::bundled` fails its checksum on Windows.
+crates/font-store/index/sources.json -text
+crates/font-store/index/indexes/*.gz binary
+
 # Copies of the vendored krilla source diff, one per patch (see vendor/krilla/README.craft.md).
 vendor/krilla/patches/*.patch linguist-generated=true

.github/workflows/workspace.yml

@@ -12,64 +12,66 @@ permissions:
 
 jobs:
   native:
-    name: Workspace (${{ matrix.os }})
-    timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install software Vulkan renderer
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y mesa-vulkan-drivers libvulkan1
-          echo 'WGPU_BACKEND=vulkan' >> "$GITHUB_ENV"
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt, clippy
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: workspace
-      - name: Prepare the Windows test driver
-        if: runner.os == 'Windows'
-        shell: powershell
-        run: |
-          $ErrorActionPreference = 'Stop'
-          Start-Service Spooler
-          Add-PrinterDriver -Name 'Generic / Text Only'
-      - run: cargo fmt --check
-      - run: cargo clippy --workspace --all-targets --locked -- -D warnings
-      - run: cargo clippy --workspace --all-targets --all-features --locked -- -D warnings
-      - run: cargo test --workspace --locked
-        env:
-          CRAFT_PRINT_REQUIRE_QUEUE: ${{ runner.os == 'Windows' && '1' || '0' }}
-      - run: cargo test --workspace --all-features --locked
-        env:
-          CRAFT_PRINT_REQUIRE_QUEUE: ${{ runner.os == 'Windows' && '1' || '0' }}
+    name: Workspace
+    uses: storytold/craft-common-actions/.github/workflows/gate.yml@main
+    with:
+      os: '["ubuntu-latest","windows-latest","macos-latest"]'
+      timeout-minutes: 120
+      tools: ""
+      packages: mesa-vulkan-drivers libvulkan1
+      craft-fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
+      linux-env: WGPU_BACKEND=vulkan
+      windows-env: CRAFT_PRINT_REQUIRE_QUEUE=1
+      env: CRAFT_PRINT_REQUIRE_QUEUE=0
+      setup-command: |
+        set -euo pipefail
+        corpus_fetcher=.test-inputs/photocraft
+        mkdir -p "$corpus_fetcher"
+        git -C "$corpus_fetcher" init
+        git -C "$corpus_fetcher" remote add origin https://github.com/storytold/PhotoCraft.git
+        git -C "$corpus_fetcher" fetch --quiet --depth=1 origin 74330157cb601573ae4523a95bb9132822fc3918
+        git -C "$corpus_fetcher" checkout --quiet --detach FETCH_HEAD
+        (cd "$corpus_fetcher" && cargo xtask corpus --psd --psd-tools --atn)
+        python scripts/test-fetch-pdf-test-fonts.py
+        python scripts/fetch-pdf-test-fonts.py "$RUNNER_TEMP/craft-pdf-test-fonts"
+        printf 'CRAFT_PSD_CORPUS=%s\n' "$GITHUB_WORKSPACE/$corpus_fetcher/corpus" >> "$GITHUB_ENV"
+        printf 'CRAFT_PDF_TEST_FONT_DIR=%s\n' "$RUNNER_TEMP/craft-pdf-test-fonts" >> "$GITHUB_ENV"
+      command: |
+        cargo fmt --check
+        cargo clippy --workspace --all-targets --locked -- -D warnings
+        cargo clippy --workspace --all-targets --all-features --locked -- -D warnings
+        cargo test --workspace --locked
+        cargo test --workspace --all-features --locked
+      windows-command: |
+        powershell.exe -NoProfile -Command '$ErrorActionPreference = "Stop"; Start-Service Spooler; Add-PrinterDriver -Name "Generic / Text Only"'
+        cargo fmt --check
+        cargo clippy --workspace --all-targets --locked -- -D warnings
+        cargo clippy --workspace --all-targets --all-features --locked -- -D warnings
+        cargo test --workspace --locked
+        cargo test --workspace --all-features --locked
+
   msrv:
-    name: Rust 1.95 (Linux libraries)
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@1.95.0
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: workspace-msrv
-      - run: cargo check --workspace --lib --all-features --locked
+    name: Rust 1.95
+    uses: storytold/craft-common-actions/.github/workflows/gate.yml@main
+    with:
+      os: '["ubuntu-latest"]'
+      toolchain: 1.95.0
+      targets: ""
+      tools: ""
+      craft-fonts-ref: ""
+      require-craft-fonts: false
+      timeout-minutes: 15
+      dev-debug: ""
+      command: cargo check --workspace --lib --all-features --locked
+
   wasm:
     name: UI and settings WASM
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: wasm32-unknown-unknown
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: workspace-wasm
-      - run: cargo check -p craft-ui -p craft-settings --all-features --locked --target wasm32-unknown-unknown
+    uses: storytold/craft-common-actions/.github/workflows/gate.yml@main
+    with:
+      os: '["ubuntu-latest"]'
+      targets: wasm32-unknown-unknown
+      tools: ""
+      craft-fonts-ref: ""
+      require-craft-fonts: false
+      timeout-minutes: 15
+      command: cargo check -p craft-ui -p craft-settings --all-features --locked --target wasm32-unknown-unknown

crates/dxf/src/lib.rs

@@ -768,7 +768,7 @@ fn ascii(tags: &[Tag], strings: Strings) -> Vec<u8> {
 /// Write tags as binary DXF (DXF Reference, "Binary DXF Files", R13+ layout): the sentinel,
 /// then per tag a 2-byte little-endian group code and the value in the binary form of the code's
 /// [`Kind`]: a zero-terminated string, an 8-byte real, a 2-, 4- or 8-byte integer, a 1-byte
-/// boolean, or a binary chunk (one length byte, then up to 255 bytes; longer data is split into
+/// boolean, or a binary chunk (one length byte, then up to 127 bytes; longer data is split into
 /// several groups of the same code). Strings are UTF-8 when `utf8` (R2007+), otherwise escaped as
 /// in [`write_ascii`]. A tag's value is converted to its code's kind, so a number written as text
 /// is stored as a number; a code outside the 16-bit range is skipped.
@@ -822,8 +822,8 @@ fn binary(tags: &[Tag], strings: Strings) -> Vec<u8> {
             }
             Kind::Hex => {
                 let bytes = hex_bytes(&t.value.as_str());
-                // An empty chunk is still one group, as in ASCII.
-                let mut chunks: Vec<&[u8]> = bytes.chunks(255).collect();
+                // At most 127 bytes per group, as in ASCII; an empty chunk is still one group.
+                let mut chunks: Vec<&[u8]> = bytes.chunks(127).collect();
                 if chunks.is_empty() {
                     chunks.push(&[]);
                 }

crates/dxf/tests/binary_write.rs

@@ -44,9 +44,8 @@ fn binary_converts_values_to_their_codes_kind() {
     let back = parse(&write_binary(&tags, true)).unwrap();
     assert_eq!(back[0], Tag::i(70, 12));
     assert_eq!(back[1], Tag::i(62, i64::from(i16::MAX)));
-    assert_eq!(back[2].code, 310);
-    assert_eq!(back[3].code, 310, "300 bytes are split into chunks of at most 255");
-    assert_eq!(back[2].str().len() + back[3].str().len(), 600);
+    let sizes: Vec<usize> = back.iter().filter(|t| t.code == 310).map(|t| t.str().len()).collect();
+    assert_eq!(sizes, vec![254, 254, 92], "300 bytes are split into chunks of at most 127 (254 hex digits)");
 }
 
 #[test]

crates/dxf/tests/hex_chunks.rs

@@ -2,7 +2,6 @@
 //! 1004 specify at most 127 payload bytes per chunk, even though a length byte represents 255.
 //! Inspect writer bytes without our parser; accept any compliant partition preserving payload,
 //! code and following-record framing. Oversized binary read fixtures test tolerance only.
-//! Pending writer regressions extend the chunk-size finding in issue #1025.
 //! Public DXF Reference, Group Codes in Numerical Order and Binary DXF Files:
 //! <https://help.autodesk.com/cloudhelp/2025/ENU/AutoCAD-DXF/files/GUID-3F0380A5-1C15-464D-BC66-2C5F094BCFB9.htm>
 //! <https://help.autodesk.com/cloudhelp/2025/ENU/AutoCAD-DXF/files/GUID-FC1C3C69-DBC2-49E4-893A-000D6538C0FE.htm>
@@ -100,7 +99,6 @@ fn binary_reader_tolerates_the_full_length_byte_domain() {
 }
 
 #[test]
-#[ignore = "Confirmed ASCII DXF writer nonconformance: hex payloads above 127 bytes are emitted as one oversized chunk"]
 fn ascii_writer_splits_large_payloads_into_conforming_chunks() {
     for code in (310..=319).chain([1004]) {
         for length in [128, 254, 255, 256, 1024] {
@@ -112,7 +110,6 @@ fn ascii_writer_splits_large_payloads_into_conforming_chunks() {
 }
 
 #[test]
-#[ignore = "Confirmed binary DXF writer nonconformance: 255-byte partitioning exceeds the documented 127-byte group limit"]
 fn binary_writer_splits_large_payloads_into_conforming_chunks() {
     for code in (310..=319).chain([1004]) {
         for length in [128, 254, 255, 256, 1024] {

crates/dxf/tests/roundtrip.rs

@@ -120,7 +120,7 @@ fn hex_chunks_keep_bytes_and_order() {
     // DXF groups 310–319 and 1004 permit 127 payload bytes per chunk. A binary length
     // byte can represent more, but that is reader tolerance, not writer conformance.
     // Larger payloads need chunk-size/reassembly checks rather than exact tag equality;
-    // see hex_chunks.rs for the independent wire checks and pending writer regressions.
+    // see hex_chunks.rs for the independent wire checks.
     for length in [0, 1, 2, 126, 127] {
         let hex: String = (0..length).fold(String::new(), |mut out, i| {
             use std::fmt::Write as _;

crates/openpgp/src/tests.rs

@@ -443,7 +443,8 @@ fn the_unhashed_area_never_decides_who_is_blamed() {
 
     // An issuer only in the unhashed area finds a key, which counts because it fits.
     let alice = secret(ALICE, Make::default());
-    let mut config = config(&alice.primary_key, pgp::packet::SignatureType::Binary, t, vec![]);
+    let alice_created = made(&alice);
+    let mut config = config(&alice.primary_key, pgp::packet::SignatureType::Binary, alice_created, vec![]);
     config.hashed_subpackets.retain(|p| matches!(p.data, SubpacketData::SignatureCreationTime(_)));
     config.unhashed_subpackets = vec![Subpacket::regular(SubpacketData::IssuerFingerprint(alice.primary_key.fingerprint())).unwrap()];
     let sig = config.sign(&alice.primary_key, &Password::empty(), SIGNED_PART.as_bytes()).unwrap();

crates/proof/src/hunspell.rs

@@ -754,11 +754,12 @@ mod tests {
     /// spec's default `~/.local/share` applies, and with no home there is no folder.
     #[test]
     fn xdg_data_home_follows_the_spec() {
-        let home = Path::new("/home/a");
-        assert_eq!(xdg_data_home(Some("/data".into()), Some(home)), Some(PathBuf::from("/data")));
-        assert_eq!(xdg_data_home(Some("/data".into()), None), Some(PathBuf::from("/data")));
+        let home = std::env::temp_dir().join("xdg-home");
+        let data = std::env::temp_dir().join("xdg-data");
+        assert_eq!(xdg_data_home(Some(data.as_os_str().to_owned()), Some(&home)), Some(data.clone()));
+        assert_eq!(xdg_data_home(Some(data.as_os_str().to_owned()), None), Some(data));
         for xdg in [None, Some(""), Some("relative/data")] {
-            assert_eq!(xdg_data_home(xdg.map(Into::into), Some(home)), Some(home.join(".local/share")), "{xdg:?}");
+            assert_eq!(xdg_data_home(xdg.map(Into::into), Some(&home)), Some(home.join(".local/share")), "{xdg:?}");
             assert_eq!(xdg_data_home(xdg.map(Into::into), None), None, "{xdg:?}");
         }
     }
@@ -1010,7 +1011,12 @@ mod tests {
         assert!(load(&aff, &big).unwrap_err().contains("too large"));
         // A directory, and on Unix an endless device, are not dictionary files. (No clock: a
         // reader that read `/dev/zero` would never return, so the error itself is the proof.)
-        assert!(load(&aff, &dir).unwrap_err().contains("not a regular file"));
+        let error = load(&aff, &dir).unwrap_err();
+        // Windows may reject opening a directory before the reader can inspect its type.
+        #[cfg(unix)]
+        assert!(error.contains("not a regular file"), "{error}");
+        #[cfg(not(unix))]
+        assert!(!error.is_empty());
         #[cfg(unix)]
         assert!(load(&aff, Path::new("/dev/zero")).unwrap_err().contains("not a regular file"));
         // Turkish reads through the same reader.