undici-types 6.29.1

Source: https://github.com/nodejs/undici
Tag scanned: v6.29.1
Compared with: v6.29.0 (0 signals introduced since)
Files: 1872 scanned, 1674 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 57 info
Scan time: 25.9 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 35 of 35 warn and critical signals; 35 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-16 09:41

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

info long-line docs/docs/api/api-lifecycle.md:61:1

line length 842 characters (raw pass, confidence 0.50)

The **idle** state is the initial state of a `Client` instance. While an `origin` is required for instantiating a `Client` instance, the underlying socket connection will not be established until a request is queued using [`Client.dispatch()`](Client.md#clientdispatchoptions-handlers). By calling `Client.dispatch()` di

info long-line lib/llhttp/constants.js:3:1

line length 585 characters (raw pass, confidence 0.50)

exports.SPECIAL_HEADERS = exports.HEADER_STATE = exports.MINOR = exports.MAJOR = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.STRICT_TOKEN = exports.HEX = exports.URL_CHAR = exports.STRICT_URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_

info dynamic-execution lib/web/fileapi/util.js:249:20

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
      for (const chunk of bytes) {
        dataURL += btoa(decoder.write(chunk))
      }
```
info dynamic-execution lib/web/fileapi/util.js:252:18

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
      dataURL += btoa(decoder.end())

      return dataURL
```
info ~~warn~~ → info by review encoding-base64 test/fetch/integrity.js:126:24

base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)
```
  await assert.rejects(fetch(`http://localhost:${server.address().port}`, {
    integrity: 'sha384-ypeBEsobvcr6wjGzmiPcTaeG7/gUfE5yuYB3ha/uSLs='
  }))
})
```
likely benign LLM, confidence 0.95 A sha384 integrity hash literal used in a fetch test.
Reasoning
The base64 string is a sha384 SRI digest passed to fetch in a test asserting rejection on a mismatched integrity value. This is a legitimate test constant.
info ~~warn~~ → info by review encoding-base64 test/fetch/integrity.js:148:24

base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)
```
  await assert.rejects(fetch(`http://localhost:${server.address().port}`, {
    integrity: 'sha512-ypeBEsobvcr6wjGzmiPcTaeG7/gUfE5yuYB3ha/uSLs='
  }))
})
```
likely benign LLM, confidence 0.95 A sha512 integrity hash literal used in a fetch test.
Reasoning
The base64 string is a sha512 SRI digest used as a test input for a fetch integrity check. Raw-pass base64 matches on hash literals are expected false positives.
info unicode-surrogate test/fixtures/wpt/FileAPI/blob/Blob-constructor.any.js:450:9

surrogate pair \uD801\uDC7E (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)
```
  [[], '\u00E5', ''],
  [[], '\uD801\uDC7E', ''], // U+1047E
  [[], ' image/gif ', ' image/gif '],
  [[], '\timage/gif\t', ''],
```
info ~~warn~~ → info by review encoding-hex test/fixtures/wpt/FileAPI/support/send-file-form-helper.js:93:8

17 consecutive `\xNN` escapes (entropy 3.6 bits/byte) (raw pass, confidence 0.65)
```
const kTestFallbackUtf8 = (
  "ABC~\xE2\x80\xBE\xC2\xA5\xE2\x89\x88\xC2\xA4\xEF\xBD\xA5\xE3\x83\xBB\xE2" +
    "\x80\xA2\xE2\x88\x99\xC2\xB7\xE2\x98\xBC\xE2\x98\x85\xE6\x98\x9F\xF0\x9F" +
    "\x8C\x9F\xE6\x98\x9F\xE2\x98\x85\xE2\x98\xBC\xC2\xB7\xE2\x88\x99\xE2\x80" +
```
likely benign LLM, confidence 0.95 UTF-8 byte escape sequences encoding a test string with mixed Unicode characters.
Reasoning
A run of \xNN escapes spells out UTF-8 bytes for non-ASCII test strings in a standard WPT FileAPI fixture. This is intentional encoding test data.
info ~~warn~~ → info by review encoding-hex test/fixtures/wpt/FileAPI/support/send-file-form-helper.js:94:6

18 consecutive `\xNN` escapes (entropy 3.5 bits/byte) (raw pass, confidence 0.65)
```
  "ABC~\xE2\x80\xBE\xC2\xA5\xE2\x89\x88\xC2\xA4\xEF\xBD\xA5\xE3\x83\xBB\xE2" +
    "\x80\xA2\xE2\x88\x99\xC2\xB7\xE2\x98\xBC\xE2\x98\x85\xE6\x98\x9F\xF0\x9F" +
    "\x8C\x9F\xE6\x98\x9F\xE2\x98\x85\xE2\x98\xBC\xC2\xB7\xE2\x88\x99\xE2\x80" +
    "\xA2\xE3\x83\xBB\xEF\xBD\xA5\xC2\xA4\xE2\x89\x88\xC2\xA5\xE2\x80\xBE~XYZ"
```
likely benign LLM, confidence 0.95 UTF-8 byte escapes continuing the mixed-Unicode test string.
Reasoning
Continuation of the same UTF-8 byte-escape test string in a WPT fixture. Expected for encoding conformance tests.
info ~~warn~~ → info by review encoding-hex test/fixtures/wpt/FileAPI/support/send-file-form-helper.js:96:6

17 consecutive `\xNN` escapes (entropy 3.7 bits/byte) (raw pass, confidence 0.65)
```
    "\x8C\x9F\xE6\x98\x9F\xE2\x98\x85\xE2\x98\xBC\xC2\xB7\xE2\x88\x99\xE2\x80" +
    "\xA2\xE3\x83\xBB\xEF\xBD\xA5\xC2\xA4\xE2\x89\x88\xC2\xA5\xE2\x80\xBE~XYZ"
);
```
likely benign LLM, confidence 0.95 UTF-8 byte escapes ending the mixed-Unicode test string.
Reasoning
Final part of the same UTF-8 byte-escape test string in a WPT fixture. No malicious behavior is present.
info ~~critical~~ → info by review dynamic-execution test/fixtures/wpt/common/dispatcher/dispatcher.js:260:29

`eval` called with a non-literal expression (ast pass, confidence 0.75)
```
      try {
        const value = await eval(task.fn).apply(null, task.args);
        response = JSON.stringify({
          status: 'success',
```
likely benign LLM, confidence 0.75 Test dispatcher evaluates a function source string received as a task.
Reasoning
The WPT test dispatcher evals a function string sent by the test harness to run test tasks. This is by design in a test framework, though eval of received content is a risky pattern if shipped outside test fixtures.
info ~~critical~~ → info by review dynamic-execution test/fixtures/wpt/common/dispatcher/executor-service-worker.js:21:5

`eval` called with a non-literal expression (ast pass, confidence 0.90)
```
    let task = await receive(uuid);
    eval(`(async () => {${task}})()`);
  }
};
```
likely benign LLM, confidence 0.75 Service-worker test executor evals task code received from the test server.
Reasoning
The service-worker executor evals task text received from the WPT dispatcher to run tests inside the worker. This is test-harness design, with no obfuscation or hidden payload.
info ~~critical~~ → info by review dynamic-execution test/fixtures/wpt/common/dispatcher/executor-worker.js:9:5

`eval` called with a non-literal expression (ast pass, confidence 0.90)
```
    let task = await receive(uuid);
    eval(`(async () => {${task}})()`);
  }
};
```
likely benign LLM, confidence 0.75 Worker test executor evals task code received from the test server.
Reasoning
The worker test executor evals task code from the WPT dispatcher as part of its test-running role. It is a test fixture pattern, not a dropper.
info dynamic-execution test/fixtures/wpt/common/security-features/resources/common.sub.js:1219:51

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
      .then(source => {
          return 'data:text/javascript;base64,' + btoa(source);
        });
  } else {
```
info ~~warn~~ → info by review dynamic-execution test/fixtures/wpt/eventsource/resources/cors.py:9:5

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
    environ = {u"__file__": path}
    exec(compile(open(path, u"r").read(), path, u'exec'), environ, environ)
    rv = environ[u"main"](request, response)
    return rv
```
likely benign LLM, confidence 0.80 Python WPT handler execs a local resource file to invoke its main function.
Reasoning
The WPT Python handler execs a test resource file from a fixed local path to run its main function. This is a standard server-side test handler pattern with no obfuscation.
info ~~warn~~ → info by review dynamic-execution test/fixtures/wpt/eventsource/resources/cors.py:9:10

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
    environ = {u"__file__": path}
    exec(compile(open(path, u"r").read(), path, u'exec'), environ, environ)
    rv = environ[u"main"](request, response)
    return rv
```
likely benign LLM, confidence 0.80 Python WPT handler compiles a local resource file as part of the exec call.
Reasoning
The compile call is the inner part of the same exec of a local test resource file. It is benign test-handler behavior.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/api/basic/integrity.sub.any.js:31:39

base64-like blob (86 bytes, compression ratio 1.13) (raw pass, confidence 0.60)
```
const topSha512wrongpadding = "sha512-D6yns0qxG0E7+TwkevZ4Jt5t7Iy3ugmAajG/dlf6Pado1JqTyneKXICDiqFIkLMRExgtvg8PlxbKTkYfRejSOg";
const topSha512base64url = "sha512-D6yns0qxG0E7-TwkevZ4Jt5t7Iy3ugmAajG_dlf6Pado1JqTyneKXICDiqFIkLMRExgtvg8PlxbKTkYfRejSOg==";
```
likely benign LLM, confidence 0.95 SRI sha512 hash literals in a fetch integrity conformance test.
Reasoning
The base64 strings are SRI sha512 digests, including base64url and padding variants, used to test fetch integrity handling. These are expected test vectors.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/api/basic/integrity.sub.any.js:32:72

base64-like blob (52 bytes, compression ratio 1.21) (raw pass, confidence 0.60)
```
const topSha512base64url = "sha512-D6yns0qxG0E7-TwkevZ4Jt5t7Iy3ugmAajG_dlf6Pado1JqTyneKXICDiqFIkLMRExgtvg8PlxbKTkYfRejSOg==";
const topSha512base64url_nopadding = "sha512-D6yns0qxG0E7-TwkevZ4Jt5t7Iy3ugmAajG_dlf6Pado1JqTyneKXICDiqFIkLMRExgtvg8PlxbKTkYfRejSOg";
```
likely benign LLM, confidence 0.95 More SRI sha512 hash literals for base64url integrity test cases.
Reasoning
Additional sha512 SRI hash literals in the same integrity conformance test file. Expected test data.
info ~~warn~~ → info by review encoding-hex test/fixtures/wpt/fetch/api/basic/text-utf8.any.js:53:20

18 consecutive `\xNN` escapes (entropy 3.9 bits/byte) (raw pass, confidence 0.65)
```
var utf8WithBOM = "\xef\xbb\xbf\xe4\xb8\x89\xe6\x9d\x91\xe3\x81\x8b\xe3\x81\xaa\xe5\xad\x90";
var utf8WithBOMAsURLParameter = "%EF%BB%BF%E4%B8%89%E6%9D%91%E3%81%8B%E3%81%AA%E5%AD%90";
var utf8WithoutBOM = "\xe4\xb8\x89\xe6\x9d\x91\xe3\x81\x8b\xe3\x81\xaa\xe5\xad\x90";
```
likely benign LLM, confidence 0.95 UTF-8 byte-escape literals encoding CJK test strings.
Reasoning
The \xNN escapes are UTF-8 byte sequences for CJK test strings in a WPT text-decoding conformance test. This is intentional test data.

info dynamic-execution test/fixtures/wpt/fetch/api/credentials/authentication-basic.any.js:5:49

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)

  promise_test(function(test) {
    var headers = { "Authorization": "Basic " + btoa(user + ":" + pass)};
    var requestInit = {"credentials": mode, "headers": headers};
    return fetch("../resources/authentication.py?realm=test", requestInit).then(function(resp) {

info dynamic-execution test/fixtures/wpt/fetch/api/credentials/authentication-redirection.any.js:4:39

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
const authorizationValue = "Basic " + btoa("user:pass");
async function getAuthorizationHeaderValue(url)
{
```

info unicode-surrogate test/fixtures/wpt/fetch/api/response/response-static-json.any.js:85:5

orphaned low surrogate \uDF06 (no preceding high surrogate) (token pass, confidence 0.65)

  ["𝌆", [34, 240, 157, 140, 134, 34]],
  ["\uDF06\uD834", [34, 92, 117, 100, 102, 48, 54, 92, 117, 100, 56, 51, 52, 34]],
  ["\uDEAD", [34, 92, 117, 100, 101, 97, 100, 34]],
];

info unicode-surrogate test/fixtures/wpt/fetch/api/response/response-static-json.any.js:85:11

orphaned high surrogate \uD834 (no matching low surrogate) (token pass, confidence 0.65)

  ["𝌆", [34, 240, 157, 140, 134, 34]],
  ["\uDF06\uD834", [34, 92, 117, 100, 102, 48, 54, 92, 117, 100, 56, 51, 52, 34]],
  ["\uDEAD", [34, 92, 117, 100, 101, 97, 100, 34]],
];

info unicode-surrogate test/fixtures/wpt/fetch/api/response/response-static-json.any.js:86:5

orphaned low surrogate \uDEAD (no preceding high surrogate) (token pass, confidence 0.65)
```
  ["\uDF06\uD834", [34, 92, 117, 100, 102, 48, 54, 92, 117, 100, 56, 51, 52, 34]],
  ["\uDEAD", [34, 92, 117, 100, 101, 97, 100, 34]],
];
```
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/compression-dictionary/resources/compressed-data.py:6:12

base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)
```
        b"Content-Dictionary",
        b":U5abz16WDg7b8KS93msLPpOB4Vbef1uRzoORYkJw9BY=:")

    # `br_d_data` and `zstd_d_data` are generated using the following commands:
```
likely benign LLM, confidence 0.95 Base64-encoded dictionary hash value used in a Compression Dictionary Transport test.
Reasoning
The blob is a Structured Fields byte sequence for a dictionary hash in a WPT test resource; it is test data, not obfuscation.
info ~~warn~~ → info by review payload-bytes-literal test/fixtures/wpt/fetch/compression-dictionary/resources/compressed-data.py:15:17

bytes literal contains 39 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
    # $ xxd -p /tmp/out.brd | tr -d '\n' | sed 's/$..$/\\x\1/g'
    br_d_data = b"\xa1\x98\x01\x80\x62\xa4\x4c\x1d\xdf\x12\x84\x8c\xae\xc2\xca\x60\x22\x07\x6e\x81\x05\x14\xc9\xb7\xc3\x44\x8e\xbc\x16\xe0\x15\x0e\xec\xc1\xee\x34\x33\x3e\x0d"
    # $ zstd -o /tmp/out.zstdd -D /tmp/dict /tmp/data
```
likely benign LLM, confidence 0.95 Bytes literal holding a brotli-compressed test payload with documented generation steps.
Reasoning
The byte literal is pre-generated brotli compressed test data, with the generation commands documented in comments. This is a legitimate binary fixture in a web-platform test suite.
info ~~warn~~ → info by review encoding-escape-soup test/fixtures/wpt/fetch/compression-dictionary/resources/compressed-data.py:15:19

39 consecutive `\xNN` escapes (entropy 5.3 bits/byte) (raw pass, confidence 0.80)
```
    # $ xxd -p /tmp/out.brd | tr -d '\n' | sed 's/$..$/\\x\1/g'
    br_d_data = b"\xa1\x98\x01\x80\x62\xa4\x4c\x1d\xdf\x12\x84\x8c\xae\xc2\xca\x60\x22\x07\x6e\x81\x05\x14\xc9\xb7\xc3\x44\x8e\xbc\x16\xe0\x15\x0e\xec\xc1\xee\x34\x33\x3e\x0d"
    # $ zstd -o /tmp/out.zstdd -D /tmp/dict /tmp/data
```
likely benign LLM, confidence 0.93 Hex-escaped binary data for the brotli test payload.
Reasoning
Hex escape soup is the expected representation of binary compressed data in a Python test fixture; the raw pass has a high false-positive rate here.
info ~~warn~~ → info by review payload-bytes-literal test/fixtures/wpt/fetch/compression-dictionary/resources/compressed-data.py:18:19

bytes literal contains 43 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
    # $ xxd -p /tmp/out.zstdd | tr -d '\n' | sed 's/$..$/\\x\1/g'
    zstd_d_data = b"\x28\xb5\x2f\xfd\x24\x34\xf5\x00\x00\x98\x63\x6f\x6d\x70\x72\x65\x73\x73\x65\x64\x61\x74\x61\x20\x75\x73\x69\x6e\x67\x03\x00\x59\xf9\x73\x54\x46\x27\x26\x10\x9e\x99\xf2\xbc"

    if b'content_encoding' in request.GET:
```
likely benign LLM, confidence 0.95 Bytes literal holding a zstd-compressed test payload.
Reasoning
The zstd-compressed fixture is documented with generation commands and is used to test content-encoding handling. It is ordinary test data.
info ~~warn~~ → info by review encoding-escape-soup test/fixtures/wpt/fetch/compression-dictionary/resources/compressed-data.py:18:21

43 consecutive `\xNN` escapes (entropy 5.0 bits/byte) (raw pass, confidence 0.80)
```
    # $ xxd -p /tmp/out.zstdd | tr -d '\n' | sed 's/$..$/\\x\1/g'
    zstd_d_data = b"\x28\xb5\x2f\xfd\x24\x34\xf5\x00\x00\x98\x63\x6f\x6d\x70\x72\x65\x73\x73\x65\x64\x61\x74\x61\x20\x75\x73\x69\x6e\x67\x03\x00\x59\xf9\x73\x54\x46\x27\x26\x10\x9e\x99\xf2\xbc"

    if b'content_encoding' in request.GET:
```
likely benign LLM, confidence 0.93 Hex-escaped zstd payload in a WPT fixture.
Reasoning
Hex escapes encode binary zstd test data, a normal pattern in this fixture file.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/compression-dictionary/resources/compression-dictionary-util.js:4:7

base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)
```
const kDefaultDictionaryHashBase64 =
    ':U5abz16WDg7b8KS93msLPpOB4Vbef1uRzoORYkJw9BY=:';
const kRegisterDictionaryPath = './resources/register-dictionary.py';
const kCompressedDataPath = './resources/compressed-data.py';
```
likely benign LLM, confidence 0.94 Base64 default dictionary hash constant in a WPT test utility.
Reasoning
The same dictionary hash value appears as a constant in the matching test utility. It is a test identifier, not a payload.
info dynamic-execution test/fixtures/wpt/fetch/compression-dictionary/resources/compression-dictionary-util.js:29:16

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
  const digest = await crypto.subtle.digest('SHA-256', encoded)
  return ':' + btoa(String.fromCharCode(...new Uint8Array(digest))) + ':';
}
```
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/data-urls/navigate.window.js:12:35

base64-like blob (60 bytes, compression ratio 1.18) (raw pass, confidence 0.60)
```
  {
    input: "data:text/html;base64,PHNjcmlwdD5wYXJlbnQucG9zdE1lc3NhZ2UoMiwgJyonKTwvc2NyaXB0Pg==",
    result: 2,
    name: "base64",
```
likely benign LLM, confidence 0.97 Base64 data URL input in a WPT navigation test.
Reasoning
This is a standard data: URL test input encoding a small HTML script for the WHATWG fetch spec tests.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/data-urls/navigate.window.js:22:58

base64-like blob (55 bytes, compression ratio 1.20) (raw pass, confidence 0.60)
```
  {
    input: "data:text/html;base64,PHNjcml%09%20%20%0A%0C%0DwdD5wYXJlbnQucG9zdE1lc3NhZ2UoNiwgJyonKTwvc2NyaXB0Pg==",
    result: 6,
    name: "ASCII whitespace in the input is removed"
```
likely benign LLM, confidence 0.97 Data URL test case with embedded ASCII whitespace in base64.
Reasoning
The percent-encoded whitespace inside the base64 data URL is deliberate, testing that ASCII whitespace is stripped per spec.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/data-urls/navigate.window.js:45:35

base64-like blob (59 bytes, compression ratio 1.19) (raw pass, confidence 0.60)
```
  {
    input: "data:text/html;base64,PHNjcmlwdD5wYXJlbnQucG9zdE1lc3NhZ2UoMywgJyonKTwvc2NyaXB0Pg=",
    name: "base64 with incorrect padding",
  },
```
likely benign LLM, confidence 0.97 Data URL test case with malformed base64 padding.
Reasoning
This data URL intentionally has incorrect base64 padding to test parser behavior.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/data-urls/navigate.window.js:53:36

base64-like blob (62 bytes, compression ratio 1.18) (raw pass, confidence 0.60)
```
  {
    input: "data:text/html;base64,%0BPHNjcmlwdD5wYXJlbnQucG9zdE1lc3NhZ2UoNywgJyonKTwvc2NyaXB0Pg==",
    name: "Vertical tab in the input leads to an error"
  }
```
likely benign LLM, confidence 0.97 Data URL test case containing a vertical tab in base64.
Reasoning
A vertical tab is deliberately placed in the data URL to test the expected error path.
info dynamic-execution test/fixtures/wpt/fetch/http-cache/http-cache.js:133:39

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
  if ('cache' in config) init.cache = config['cache']
  init.headers.push(['Test-Requests', btoa(JSON.stringify(requests))])
  return init
}
```
info dynamic-execution test/fixtures/wpt/fetch/http-cache/http-cache.js:270:19

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
  } else {
    var content = btoa(Math.random() * Date.now())
    contentStore[csKey] = content
    return content
```
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/redirects/data.window.js:7:76

base64-like blob (136 bytes, compression ratio 0.90) (raw pass, confidence 0.60)
```
rces/redirect.py?location=data:image/png%3Bbase64,iVBORw0KGgoAAAANSUhEUgAAAIUAAABqCAIAAAAdqgU8AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAF6SURBVHhe7dNBDQAADIPA%2Bje92eBxSQUQSLedlQzo0TLQonFWPVoGWjT%2BoUfLQIvGP/RoGWjR%2BIceLQMtGv/Qo2WgReMferQMtGj8Q4%2BWgRaNf%2BjRMtCi8Q89WgZaNP6hR8tAi8Y/9GgZaNH4
```
likely benign LLM, confidence 0.93 URL-encoded base64 PNG data URI in a redirect test.
Reasoning
This is a URL-encoded PNG data URI used as a redirect target in a WPT test, a standard image payload.
info ~~critical~~ → info by review dynamic-execution test/fixtures/wpt/resources/idlharness.js:2754:15

`eval` called with a non-literal expression (ast pass, confidence 0.75)
```
    {
        obj = eval(desc);
    }
    catch(e)
```
likely benign LLM, confidence 0.90 eval of a descriptor expression inside the WPT IDL test harness.
Reasoning
idlharness.js is the WPT IDL harness, which uses eval on generated descriptor strings in a try block to test IDL. The eval is in a test framework, not attacker-controlled input, though a non-literal eval remains a generic risk.
info ~~warn~~ → info by review error-stack-inspection test/fixtures/wpt/resources/testharness.js:1613:26

`indexOf` called on `new Error().stack` — string-matching the call stack is the structural shape of sandbox/analyzer detection (ast pass, confidence 0.85)
```
                 if (typeof actual[p] === "object" && actual[p] !== null) {
                     if (stack.indexOf(actual[p]) === -1) {
                         check_equal(actual[p], expected[p], stack);
                     }
```
likely benign LLM, confidence 0.80 Recursive deep-equal in the WPT test harness uses a stack array for cycle detection.
Reasoning
This is WPT's testharness cycle detection: checking whether an object is already in a stack used for recursive comparison. It is not sandbox or analyzer detection; the Error stack is not being inspected for evasion.

info whitespace-anomaly test/fixtures/wpt/resources/webidl2/lib/webidl2.js:2:1

file mixes tab and space indentation (8 tab-indented and 2451 space-indented lines) (raw pass, confidence 0.40)

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)

info unicode-surrogate test/fixtures/wpt/service-workers/cache-storage/cache-storage.https.any.js:206:34

orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)
```
promise_test(function(t) {
    var unpaired_name = 'unpaired\uD800';
    var converted_name = 'unpaired\uFFFD';
```
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/service-workers/service-worker/resources/fetch-access-control.py:32:30

base64-like blob (72 bytes, compression ratio 1.15) (raw pass, confidence 0.60)
```
        headers.append((b"Content-Type", b"image/png"))
        body = decodebytes(b"iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1B"
                           b"AACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/KfgQLABKXJBqMG"
```
likely benign LLM, confidence 0.85 Base64 PNG image bytes passed to decodebytes for a test response body.
Reasoning
This is a standard base64-encoded 1x1 PNG image literal used as a test response body in a web-platform-tests fixture. Encoded image data in test fixtures is expected.

info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/service-workers/service-worker/resources/fetch-access-control.py:33:30

base64-like blob (72 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

        body = decodebytes(b"iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1B"
                           b"AACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/KfgQLABKXJBqMG"
                           b"jBoAAqMGDLwBDAwAEsoCTFWunmQAAAAASUVORK5CYII=")
        return headers, body

likely benign LLM, confidence 0.85 Continuation line of a base64 PNG test image literal.

Reasoning

Continuation of the same base64-encoded PNG test fixture; benign test data.

info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/service-workers/service-worker/resources/fetch-access-control.py:34:30

base64-like blob (44 bytes, compression ratio 1.11) (raw pass, confidence 0.60)
```
                           b"AACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/KfgQLABKXJBqMG"
                           b"jBoAAqMGDLwBDAwAEsoCTFWunmQAAAAASUVORK5CYII=")
        return headers, body
```
likely benign LLM, confidence 0.85 Final base64 fragment of a PNG test image literal.
Reasoning
Final fragment of the same base64 PNG literal used in a WPT service worker test; no execution or hidden payload.
info ~~warn~~ → info by review dynamic-execution test/fixtures/wpt/service-workers/service-worker/resources/fetch-rewrite-worker.js:58:20

`atob` decodes a base64 value at runtime — common step before dynamic fetch or eval (ast pass, confidence 0.75)
```
    if (params['generate-png']) {
      var binary = atob(
          'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAA' +
          'RnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/Kf' +
```
likely benign LLM, confidence 0.85 atob decodes an embedded PNG to build image bytes in a test worker.
Reasoning
atob decodes a PNG image into a Uint8Array to generate a test response when the generate-png parameter is set. This is ordinary image generation in a test worker, not an eval or dropper.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/service-workers/service-worker/resources/fetch-rewrite-worker.js:60:12

base64-like blob (66 bytes, compression ratio 1.17) (raw pass, confidence 0.60)
```
          'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAA' +
          'RnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/Kf' +
          'gQLABKXJBqMGjBoAAqMGDLwBDAwAEsoCTFWunmQAAAAASUVORK5CYII=');
      var array = new Uint8Array(binary.length);
```
likely benign LLM, confidence 0.85 Base64 PNG constant fragment in a service worker test.
Reasoning
Same embedded base64 PNG constant used for test image generation; benign.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/service-workers/service-worker/resources/fetch-rewrite-worker.js:61:12

base64-like blob (56 bytes, compression ratio 1.20) (raw pass, confidence 0.60)
```
          'RnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/Kf' +
          'gQLABKXJBqMGjBoAAqMGDLwBDAwAEsoCTFWunmQAAAAASUVORK5CYII=');
      var array = new Uint8Array(binary.length);
      for(var i = 0; i < binary.length; i++) {
```
likely benign LLM, confidence 0.85 Base64 PNG constant tail in a service worker test.
Reasoning
Continuation of the same benign base64 PNG constant used to produce test image bytes.
info ~~warn~~ → info by review dynamic-import test/fixtures/wpt/service-workers/service-worker/resources/no-dynamic-import.js:15:45

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  promise_test(
    (t) => promise_rejects_js(t, TypeError, import(url), "Import must reject"),
    name
  );
```
likely benign LLM, confidence 0.88 Dynamic import of a test URL used to assert that the import rejects.
Reasoning
The import() call is inside a test asserting that dynamic import rejects, as the test name suggests. The specifier is a test-controlled URL, and the code is a test of import behavior rather than an attack.
info unicode-surrogate test/fixtures/wpt/websockets/Close-reason-unpaired-surrogates.any.js:11:15

orphaned high surrogate \uD807 (no matching low surrogate) (token pass, confidence 0.65)
```
var replacementChar = "\uFFFD";
var reason = "\uD807";

wsocket.addEventListener('open', test.step_func(function(evt) {
```
info unicode-surrogate test/fixtures/wpt/websockets/Send-paired-surrogates.any.js:8:13

surrogate pair \uD801\uDC07 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)
```
var data = "\uD801\uDC07";
var wsocket = CreateWebSocket(false, false);
var isOpenCalled = false;
```
info unicode-surrogate test/fixtures/wpt/websockets/Send-unpaired-surrogates.any.js:8:13

orphaned high surrogate \uD807 (no matching low surrogate) (token pass, confidence 0.65)
```
var data = "\uD807";
var replacementChar = "\uFFFD";
var wsocket = CreateWebSocket(false, false);
```
info ~~warn~~ → info by review long-line test/fixtures/wpt/xhr/resources/over-1-meg.txt:1:1

line length 1160000 characters (raw pass, confidence 0.65)
```
abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd
```
likely benign LLM, confidence 0.93 Large repetitive text fixture for XHR size tests.
Reasoning
A plain text fixture of repeated 'abcd' used to test XHR handling of responses over 1MB. A long line is expected in this data file.
info ~~warn~~ → info by review narrow-file-charset test/fixtures/wpt/xhr/resources/over-1-meg.txt:1:1

file uses only 4 distinct printable characters ("abcd") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd
```
likely benign LLM, confidence 0.93 Four-character repeating text fixture flagged for narrow charset.
Reasoning
The repetitive 'abcd' content is a size-test filler file, not JSFuck-style code. No executable payload exists in a plain text fixture.
info unicode-surrogate test/fixtures/wpt/xhr/send-data-string-invalid-unicode.any.js:3:25

orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
```
const LEFT_SURROGATE = '\ud83d';
const RIGHT_SURROGATE = '\udc94';
```
info unicode-surrogate test/fixtures/wpt/xhr/send-data-string-invalid-unicode.any.js:4:26

orphaned low surrogate \uDC94 (no preceding high surrogate) (token pass, confidence 0.65)
```
const LEFT_SURROGATE = '\ud83d';
const RIGHT_SURROGATE = '\udc94';

// Unmatched surrogates should be replaced with the unicode replacement
```
info dynamic-execution test/fixtures/wpt/xhr/xhr-authorization-redirect.any.js:4:39

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
const authorizationValue = "Basic " + btoa("user:pass");
function getAuthorizationHeaderValue(url)
{
```

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.0.0
git clone https://github.com/nodejs/undici undici && cd undici
git checkout v6.29.1
disclude scan --severity info --diff v6.29.0 .