yaml guard: charge lone surrogates at their escaped length

serializedStringLength treated surrogate code units as cost 1, but
well-formed JSON.stringify escapes a lone surrogate to \uXXXX (six units).
Charge lone surrogates as 6 and valid high+low pairs as-is (two units),
matching JSON.stringify exactly. Verified against JSON.stringify across
plain text, escapes, control chars, lone high/low surrogates, and valid
pairs.

Author: waleedlatif1

apps/sim/lib/file-parsers/yaml-parser.test.ts

@@ -112,4 +112,16 @@ describe('assertYamlWithinLimits', () => {
     expect(() => assertYamlWithinLimits({ text: escapeHeavy })).toThrow(YamlComplexityError)
     expect(escapeHeavy.length).toBeLessThan(64 * 1024 * 1024)
   })
+
+  it('charges lone surrogates at their escaped length', () => {
+    // JSON.stringify escapes a lone surrogate to \uXXXX (six units). ~11M of
+    // them estimate to ~66 MB (> 64 MB) though the raw length is under the cap.
+    const loneSurrogates = String.fromCharCode(0xd800).repeat(11 * 1024 * 1024)
+    expect(loneSurrogates.length).toBeLessThan(64 * 1024 * 1024)
+    expect(() => assertYamlWithinLimits({ text: loneSurrogates })).toThrow(YamlComplexityError)
+    // A valid surrogate pair (astral char) is emitted as-is, so ~10M of them
+    // (~20M code units, ~20 MB) stays well under the cap.
+    const astral = String.fromCodePoint(0x1f600).repeat(10 * 1024 * 1024)
+    expect(() => assertYamlWithinLimits({ text: astral })).not.toThrow()
+  })
 })

apps/sim/lib/file-parsers/yaml-parser.ts

@@ -52,10 +52,11 @@ export function isYamlComplexityError(error: unknown): error is YamlComplexityEr
 /**
  * Exact serialized length (in UTF-16 code units — the unit V8 allocates for the
  * resulting string) that `JSON.stringify` produces for a string, accounting for
- * the escape expansion of quotes, backslashes, and control characters. Computed
- * precisely rather than with a flat multiplier so plain text is charged its
- * true size (no false rejection of large legitimate documents) while
- * escape-heavy strings are charged their real, larger cost (no cap bypass).
+ * the escape expansion of quotes, backslashes, control characters, and lone
+ * surrogates. Computed precisely rather than with a flat multiplier so plain
+ * text is charged its true size (no false rejection of large legitimate
+ * documents) while escape-heavy strings are charged their real, larger cost
+ * (no cap bypass).
  */
 function serializedStringLength(value: string): number {
   let length = 2 // surrounding quotes
@@ -67,6 +68,16 @@ function serializedStringLength(value: string): number {
       // \b \t \n \f \r use two-char escapes; other control chars use \uXXXX (six)
       length +=
         code === 0x08 || code === 0x09 || code === 0x0a || code === 0x0c || code === 0x0d ? 2 : 6
+    } else if (code >= 0xd800 && code <= 0xdfff) {
+      // Well-formed JSON.stringify emits a valid high+low surrogate pair as-is
+      // (two code units) but escapes a lone surrogate to \uXXXX (six).
+      const next = i + 1 < value.length ? value.charCodeAt(i + 1) : 0
+      if (code <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) {
+        length += 2
+        i++
+      } else {
+        length += 6
+      }
     } else {
       length += 1
     }