Count implicit keys by Unicode scalar

Apply the 1024-character limit with System.Text.Rune, cover plain and quoted boundaries, and retain the official multiline flow-mapping grammar while rejecting multiline flow-sequence pairs.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: MariusStorhaug

src/functions/private/Get-YamlImplicitKeyLength.ps1

@@ -0,0 +1,22 @@
+function Get-YamlImplicitKeyLength {
+    <#
+        .SYNOPSIS
+        Gets an implicit key length in Unicode scalar values.
+    #>
+    [CmdletBinding()]
+    [OutputType([int])]
+    param (
+        [Parameter(Mandatory)]
+        [pscustomobject] $Node,
+
+        [Parameter(Mandatory)]
+        [pscustomobject] $Context
+    )
+
+    if ($Node.Kind.Equals('Scalar', [System.StringComparison]::Ordinal)) {
+        return Get-YamlRuneCount -Text ([string] $Node.Value)
+    }
+
+    $sourceLength = [Math]::Max(0, $Node.End.Index - $Node.Start.Index)
+    return Get-YamlRuneCount -Text $Context.Text.Substring($Node.Start.Index, $sourceLength)
+}

src/functions/private/Get-YamlRuneCount.ps1

@@ -0,0 +1,22 @@
+function Get-YamlRuneCount {
+    <#
+        .SYNOPSIS
+        Counts Unicode scalar values in validated YAML text.
+    #>
+    [CmdletBinding()]
+    [OutputType([int])]
+    param (
+        [Parameter(Mandatory)]
+        [AllowEmptyString()]
+        [string] $Text
+    )
+
+    $count = 0
+    $index = 0
+    while ($index -lt $Text.Length) {
+        $rune = [System.Text.Rune]::GetRuneAt($Text, $index)
+        $index += $rune.Utf16SequenceLength
+        $count++
+    }
+    return $count
+}

src/functions/private/Read-YamlBlockMapping.ps1

@@ -182,14 +182,6 @@ function Read-YamlBlockMapping {
                     'A block mapping entry is missing its value indicator.'
                 ))
         }
-        if ($colon -gt 1024) {
-            $mark = New-YamlMark -Index ($Context.LineStarts[$lineNumber] + $contentColumn + $colon) `
-                -Line $lineNumber -Column ($contentColumn + $colon)
-            throw (New-YamlException -Start $mark -End $mark -ErrorId 'YamlInvalidImplicitKey' -Message (
-                    'An implicit mapping key cannot exceed 1024 characters.'
-                ))
-        }
-
         if ($colon -eq 0) {
             $mark = New-YamlMark -Index ($Context.LineStarts[$lineNumber] + $contentColumn) `
                 -Line $lineNumber -Column $contentColumn
@@ -199,6 +191,13 @@ function Read-YamlBlockMapping {
             $key = Read-YamlBlockKey -Context $Context -Text $keyText -Line $lineNumber `
                 -Column $contentColumn -Depth ($Depth + 1)
         }
+        if ((Get-YamlImplicitKeyLength -Node $key -Context $Context) -gt 1024) {
+            $mark = New-YamlMark -Index ($Context.LineStarts[$lineNumber] + $contentColumn + $colon) `
+                -Line $lineNumber -Column ($contentColumn + $colon)
+            throw (New-YamlException -Start $mark -End $mark -ErrorId 'YamlInvalidImplicitKey' -Message (
+                    'An implicit mapping key cannot exceed 1024 Unicode scalar values.'
+                ))
+        }
 
         $valueStart = $colon + 1
         $valueSource = $content.Substring($valueStart)

src/functions/private/Read-YamlFlowNode.ps1

@@ -190,11 +190,11 @@ function Read-YamlFlowNode {
                 if ($Cursor.Index -lt $Context.Text.Length -and $Context.Text[$Cursor.Index] -eq ':') {
                     if (-not $explicitPair -and (
                             $Cursor.Line -ne $itemStartLine -or
-                            $Cursor.Index - $item.Start.Index -gt 1024
+                            (Get-YamlImplicitKeyLength -Node $item -Context $Context) -gt 1024
                         )) {
                         $mark = New-YamlMark -Index $Cursor.Index -Line $Cursor.Line -Column $Cursor.Column
                         throw (New-YamlException -Start $mark -End $mark -ErrorId 'YamlInvalidImplicitKey' -Message (
-                                'An implicit mapping key must fit on one line and cannot exceed 1024 characters.'
+                                'An implicit mapping key must fit on one line and cannot exceed 1024 Unicode scalar values.'
                             ))
                     }
                     $pair = New-YamlSyntaxNode -Context $Context -Kind Mapping -Depth ($Depth + 1) `
@@ -269,10 +269,12 @@ function Read-YamlFlowNode {
                     }
                 }
                 Skip-YamlFlowTrivia -Cursor $Cursor -Context $Context
-                if (-not $explicit -and $Cursor.Index - $key.Start.Index -gt 1024) {
+                if (-not $explicit -and (
+                        (Get-YamlImplicitKeyLength -Node $key -Context $Context) -gt 1024
+                    )) {
                     $mark = New-YamlMark -Index $Cursor.Index -Line $Cursor.Line -Column $Cursor.Column
                     throw (New-YamlException -Start $mark -End $mark -ErrorId 'YamlInvalidImplicitKey' -Message (
-                            'An implicit mapping key must fit on one line and cannot exceed 1024 characters.'
+                            'An implicit mapping key must fit on one line and cannot exceed 1024 Unicode scalar values.'
                         ))
                 }
                 if ($Cursor.Index -ge $Context.Text.Length -or $Context.Text[$Cursor.Index] -ne ':') {

tests/ConvertFrom-Yaml.Tests.ps1

@@ -153,6 +153,17 @@ folded: >
 
             $result | Should -Be @('foo  bar', "foo`nbar")
         }
+
+        It 'accepts adjacent flow collection values after a colon' {
+            $sequenceValue = '{foo:[bar]}' | ConvertFrom-Yaml
+            $mappingValue = '{foo:{bar: baz}}' | ConvertFrom-Yaml
+            $sequencePair = '[foo:[bar]]' | ConvertFrom-Yaml -NoEnumerate
+
+            $sequenceValue.foo | Should -Be @('bar')
+            $mappingValue.foo.bar | Should -Be 'baz'
+            $sequencePair.Count | Should -Be 1
+            $sequencePair[0].foo | Should -Be @('bar')
+        }
     }
 
     Context 'Streams and pipeline input' {

tests/Test-Yaml.Tests.ps1

@@ -37,6 +37,37 @@ Describe 'Test-Yaml' {
         ("a: &a value`nb: !foo *a" | Test-Yaml) | Should -BeFalse
     }
 
+    It 'enforces implicit-key line and Unicode scalar limits' {
+        $emoji = [char]::ConvertFromUtf32(0x1F600)
+
+        ("['multi`n  line': value]" | Test-Yaml) | Should -BeFalse
+        ("[multi`n  line: value]" | Test-Yaml) | Should -BeFalse
+
+        foreach ($quoted in @($false, $true)) {
+            foreach ($length in @(1024, 1025)) {
+                $text = 'k' * $length
+                $key = if ($quoted) { "'$text'" } else { $text }
+                foreach ($yaml in @(
+                        "[$key`: value]",
+                        "{$key`: value}"
+                    )) {
+                    ($yaml | Test-Yaml) | Should -Be ($length -eq 1024)
+                }
+            }
+        }
+
+        foreach ($length in @(513, 1024, 1025)) {
+            $key = $emoji * $length
+            ("{$key`: value}" | Test-Yaml) |
+                Should -Be ($length -le 1024)
+        }
+    }
+
+    It 'accepts multiline keys in flow mappings' {
+        ("{'multi`n  line': value}" | Test-Yaml) | Should -BeTrue
+        ("{multi`n  line: value}" | Test-Yaml) | Should -BeTrue
+    }
+
     It 'validates tag directives, tag tokens, and alias properties' {
         ("%TAG !! tag:example.com,2000:app/`n---`n!!int value" | Test-Yaml) |
             Should -BeTrue