Fix CRLF documents collapsing to a single line in the workflow YAML scanner

Line.scan split on "\n" as a Character. Swift's Character is an extended
grapheme cluster, and CR+LF is itself one grapheme cluster, so splitting
on "\n" alone matches nothing in CRLF-encoded text: the whole document
collapses into a single pseudo-line, and GitHub.ContinuousIntegration.
Workflow.Document.jobs comes back empty.

This is not platform-conditional code — it is a Unicode-model fact that
fires on any platform whenever the input bytes are CRLF, which in
practice means a Windows git checkout of an LF-committed workflow file
(default core.autocrlf). Reproduced directly by feeding the parser CRLF
text, no Windows machine required.

Fix: normalize CRLF and bare CR to LF before splitting, which also
removes the now-redundant per-line trailing-\r strip.

Root cause for institute-continuous-integration#13's Windows-only
.noJobs failures.

Author: coenttb

Sources/GitHub Continuous Integration Workflow/GitHub.ContinuousIntegration.Workflow.YAML.Line.swift

@@ -1,3 +1,4 @@
+import Foundation
 import GitHub_Continuous_Integration
 import GitHub_Standard
 
@@ -31,10 +32,26 @@ extension GitHub.ContinuousIntegration.Workflow.YAML {
         }
 
         static func scan(_ text: String) -> [Self] {
-            text.split(separator: "\n", omittingEmptySubsequences: false)
+            // Normalise line endings *before* splitting. Swift's `Character`
+            // is an extended grapheme cluster, and CR+LF is itself one
+            // grapheme cluster — so `text.split(separator: "\n")` on a
+            // CRLF document matches nothing and the entire document
+            // collapses into a single "line". This is not
+            // platform-conditional code reading a platform fact; it is a
+            // Unicode-model fact that fires identically on every OS
+            // whenever the *input bytes* happen to be CRLF, which in
+            // practice means every Windows `git checkout` of an
+            // LF-committed workflow file (default `core.autocrlf`).
+            // Normalizing first (CRLF, then any bare CR) removes both the
+            // collapse and the per-line trailing-`\r` case entirely, so
+            // there is nothing left for `raw`/`content` to strip.
+            let normalized = text
+                .replacingOccurrences(of: "\r\n", with: "\n")
+                .replacingOccurrences(of: "\r", with: "\n")
+            return normalized.split(separator: "\n", omittingEmptySubsequences: false)
                 .enumerated()
                 .map { offset, raw in
-                    let raw = raw.hasSuffix("\r") ? String(raw.dropLast()) : String(raw)
+                    let raw = String(raw)
                     return Self(
                         number: offset + 1,
                         indent: raw.prefix(while: { $0 == " " }).count,

Tests/GitHub Continuous Integration Workflow Tests/GitHub.ContinuousIntegration.Workflow.CRLF Tests.swift

@@ -0,0 +1,59 @@
+import GitHub_Continuous_Integration
+import GitHub_Standard
+import Testing
+
+@testable import GitHub_Continuous_Integration_Workflow
+
+/// Regression coverage for the Windows-only `.noJobs` defect
+/// (institute-continuous-integration#13): a CRLF-encoded workflow
+/// document parsed to a single top-level key and zero jobs.
+///
+/// Root cause: `Line.scan` split on `"\n"` as a `Character`. Swift's
+/// `Character` is an extended grapheme cluster, and CR+LF is itself one
+/// grapheme cluster, so `text.split(separator: "\n")` on a CRLF document
+/// matches nothing and the whole document collapses into one pseudo-line.
+/// This is not Windows-conditional code — it is a Unicode-model fact that
+/// fires on any platform whenever the *input bytes* are CRLF, which in
+/// practice means every Windows `git checkout` of an LF-committed
+/// workflow file (default `core.autocrlf`). Reproduced here on macOS by
+/// feeding the parser CRLF text directly, with no Windows machine
+/// required.
+@Suite
+struct CIWorkflowCRLFTests {
+    static let caller = """
+        name: CI
+
+        on:
+          push:
+            branches: [main]
+          pull_request:
+
+        jobs:
+          ci:
+            uses: swift-primitives/.github/.github/workflows/swift-ci.yml@main
+            secrets: inherit
+          lint:
+            runs-on: ubuntu-latest
+            steps:
+              - uses: actions/checkout@v6
+        """
+
+    @Test func `CRLF document parses the same jobs as its LF original`() throws {
+        let lf = Self.caller
+        let crlf = lf.replacingOccurrences(of: "\n", with: "\r\n")
+
+        let lfDocument = try GitHub.ContinuousIntegration.Workflow.Document(name: "ci.yml", text: lf)
+        let crlfDocument = try GitHub.ContinuousIntegration.Workflow.Document(name: "ci.yml", text: crlf)
+
+        #expect(crlfDocument.jobs.map(\.name) == lfDocument.jobs.map(\.name))
+        #expect(crlfDocument.jobs.map(\.name) == ["ci", "lint"])
+    }
+
+    @Test func `a lone CR line ending is also normalised`() throws {
+        let lf = Self.caller
+        let cr = lf.replacingOccurrences(of: "\n", with: "\r")
+
+        let document = try GitHub.ContinuousIntegration.Workflow.Document(name: "ci.yml", text: cr)
+        #expect(document.jobs.map(\.name) == ["ci", "lint"])
+    }
+}